eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-22 13:59:19 +02:00
Code Issues 123 Wiki Activity

Sprawdzone do dizel_Update.

Browse Source 
Dodano funkcje wirtualne do hamulców
This commit is contained in:
firleju
2016-11-27 21:47:35 +01:00
parent f9043a254f
commit 25f85aa9a8
3 changed files with 260 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

307
McZapkie/Mover.cpp
View File

@@ -87,6 +87,7 @@ int DirF(int CouplerN)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160716 // Q: 20160716
// Obliczanie natężenie prądu w silnikach
// ************************************************************************************************* // *************************************************************************************************
double TMoverParameters::current(double n, double U) double TMoverParameters::current(double n, double U)
{ {
@@ -105,30 +106,28 @@ double TMoverParameters::current(double n, double U)
MotorCurrent = 0; MotorCurrent = 0;
// i dzialanie hamulca ED w EP09 // i dzialanie hamulca ED w EP09
//- if (DynamicBrakeType == dbrake_automatic) if (DynamicBrakeType == dbrake_automatic)
//- { {
//- if ((( static_cast<TLSt*>(Hamulec)->GetEDBCP() < 0.25) && (Vadd < 1)) || (BrakePress > if (((Hamulec->GetEDBCP() < 0.25) && (Vadd < 1)) || (BrakePress > 2.1))
//2.1)) DynamicBrakeFlag = false;
//- DynamicBrakeFlag = false; else if ((BrakePress > 0.25) && (Hamulec->GetEDBCP() > 0.25))
//- else if ((BrakePress > 0.25) && (static_cast<TLSt*>(Hamulec)->GetEDBCP() > 0.25)) DynamicBrakeFlag = true;
//- DynamicBrakeFlag = true; DynamicBrakeFlag = (DynamicBrakeFlag && ConverterFlag);
//- DynamicBrakeFlag = (DynamicBrakeFlag && ConverterFlag); }
//- }
// wylacznik cisnieniowy yBARC - to jest chyba niepotrzebne tutaj Q: no to usuwam... // wylacznik cisnieniowy yBARC - to jest chyba niepotrzebne tutaj Q: no to usuwam...
// BrakeSubsystem = ss_LSt; // BrakeSubsystem = ss_LSt;
// if (BrakeSubsystem == ss_LSt) WriteLog("LSt"); // if (BrakeSubsystem == ss_LSt) WriteLog("LSt");
if (BrakeSubsystem == ss_LSt) // if (BrakeSubsystem == ss_LSt) // zrobiona funkcja virtualna
if (DynamicBrakeFlag) if (DynamicBrakeFlag)
{ {
static_cast<TLSt *>(Hamulec) Hamulec->SetED(abs(Im / 350)); // hamulec ED na EP09 dziala az do zatrzymania lokomotywy
->SetED(abs(Im / 350)); // hamulec ED na EP09 dziala az do zatrzymania lokomotywy
//- WriteLog("A"); //- WriteLog("A");
} }
else else
{ {
static_cast<TLSt *>(Hamulec)->SetED(0); Hamulec->SetED(0);
//- WriteLog("B"); //- WriteLog("B");
} }
@@ -165,16 +164,14 @@ double TMoverParameters::current(double n, double U)
// z Megapacka ... bylo tutaj zakomentowane Q: no to usuwam... // z Megapacka ... bylo tutaj zakomentowane Q: no to usuwam...
//- if (DynamicBrakeFlag && (!FuseFlag) && (DynamicBrakeType == dbrake_automatic) && if (DynamicBrakeFlag && (!FuseFlag) && (DynamicBrakeType == dbrake_automatic) &&
//ConverterFlag && Mains) //hamowanie EP09 //TUHEX ConverterFlag && Mains) // hamowanie EP09 //TUHEX
//- { {
//- WriteLog("TUHEX"); MotorCurrent =
//- MotorCurrent = -Max0R(MotorParam[0].fi * (Vadd / (Vadd + MotorParam[0].Isat) - -Max0R(MotorParam[0].fi * (Vadd / (Vadd + MotorParam[0].Isat) - MotorParam[0].fi0), 0) *
//MotorParam[0].fi0), 0) * n * 2 / ep09resED; //TODO: zrobic bardziej uniwersalne nie tylko dla n * 2 / ep09resED; // TODO: zrobic bardziej uniwersalne nie tylko dla EP09
//EP09 }
//- } else if ((RList[MainCtrlActualPos].Bn == 0) || (!StLinFlag))
//- else
if ((RList[MainCtrlActualPos].Bn == 0) || (!StLinFlag))
MotorCurrent = 0; // wylaczone MotorCurrent = 0; // wylaczone
else else
{ // wlaczone... { // wlaczone...
@@ -188,23 +185,29 @@ double TMoverParameters::current(double n, double U)
Rz = Mn * WindingRes + R; Rz = Mn * WindingRes + R;
//- if (DynamicBrakeFlag) //hamowanie if (DynamicBrakeFlag) // hamowanie
//- { {
//- if (DynamicBrakeType > 1)
//- if (DynamicBrakeType > 1) {
//- { // if DynamicBrakeType<>dbrake_automatic then
//- // MotorCurrent:=-fi*n/Rz {hamowanie silnikiem na oporach rozruchowych}
//- if ((DynamicBrakeType == dbrake_switch) && (TrainType == dt_ET42)) /* begin
//- { //z Megapacka U:=0;
//- Rz = WindingRes + R; Isf:=Isat;
//- MotorCurrent = -MotorParam[SP].fi * n / Rz; Delta:=SQR(Isf*Rz+Mn*fi*n-U)+4*U*Isf*Rz;
////{hamowanie silnikiem na oporach rozruchowych} MotorCurrent:=(U-Isf*Rz-Mn*fi*n+SQRT(Delta))/(2*Rz)
//- } end*/
//- } if ((DynamicBrakeType == dbrake_switch) && (TrainType == dt_ET42))
//- else { // z Megapacka
//- MotorCurrent = 0; //odciecie pradu od silnika Rz = WindingRes + R;
//- } MotorCurrent =
//- else -MotorParam[SP].fi * n / Rz; //{hamowanie silnikiem na oporach rozruchowych}
}
}
else
MotorCurrent = 0; // odciecie pradu od silnika
}
else
{ {
U1 = U + Mn * n * MotorParam[SP].fi0 * MotorParam[SP].fi; U1 = U + Mn * n * MotorParam[SP].fi0 * MotorParam[SP].fi;
// writepaslog("U1 ", FloatToStr(U1)); // writepaslog("U1 ", FloatToStr(U1));
@@ -237,17 +240,15 @@ double TMoverParameters::current(double n, double U)
} }
// writepaslog("MotorCurrent ", FloatToStr(MotorCurrent)); // writepaslog("MotorCurrent ", FloatToStr(MotorCurrent));
//- if ((DynamicBrakeType == dbrake_switch) && ((BrakePress > 2.0) || (PipePress < 3.6))) if ((DynamicBrakeType == dbrake_switch) && ((BrakePress > 2.0) || (PipePress < 3.6)))
//- {
//- WriteLog("DynamicBrakeType=" + IntToStr( dbrake_switch ));
//- Im = 0;
//- MotorCurrent = 0;
//- Itot = 0;
//- }
//- else
{ {
Im = MotorCurrent; Im = 0;
MotorCurrent = 0;
// Im:=0;
Itot = 0;
} }
else
Im = MotorCurrent;
EnginePower = abs(Itot) * (1 + RList[MainCtrlActualPos].Mn) * abs(U); EnginePower = abs(Itot) * (1 + RList[MainCtrlActualPos].Mn) * abs(U);
@@ -256,22 +257,19 @@ double TMoverParameters::current(double n, double U)
if (MotorCurrent > 0) if (MotorCurrent > 0)
{ {
if (FuzzyLogic(abs(n), nmax * 1.1, p_elengproblem))
//-if FuzzyLogic(Abs(n),nmax*1.1,p_elengproblem) then if (MainSwitch(false))
//- if MainSwitch(false) then EventFlag = true; /*zbyt duze obroty - wywalanie wskutek ognia okreznego*/
//- EventFlag:=true; {zbyt duze obroty - wywalanie wskutek ognia okreznego} if (TestFlag(DamageFlag, dtrain_engine))
//-if TestFlag(DamageFlag,dtrain_engine) then if (FuzzyLogic(MotorCurrent, ImaxLo / 10.0, p_elengproblem))
//- if FuzzyLogic(MotorCurrent,ImaxLo/10.0,p_elengproblem) then if (MainSwitch(false))
//- if MainSwitch(false) then EventFlag = true; /*uszkodzony silnik (uplywy)*/
//- EventFlag:=true; if ((FuzzyLogic(abs(Im), Imax * 2, p_elengproblem) ||
// uszkodzony silnik (uplywy) FuzzyLogic(abs(n), nmax * 1.11, p_elengproblem)))
//-if ((FuzzyLogic(abs(Im), Imax * 2, p_elengproblem) || FuzzyLogic(abs(n), nmax * 1.11, /* or FuzzyLogic(Abs(U/Mn),2*NominalVoltage,1)) then */ /*poprawic potem*/
//p_elengproblem))) if ((SetFlag(DamageFlag, dtrain_engine)))
EventFlag = true;
//-if (SetFlag(DamageFlag, dtrain_engine)) /*! dorobic grzanie oporow rozruchowych i silnika*/
//- EventFlag = true;
//! dorobic grzanie oporow rozruchowych i silnika
} }
return Im; return Im;
@@ -1537,7 +1535,7 @@ double TMoverParameters::FastComputeMovement(double dt, const TTrackShape &Shape
}; };
double TMoverParameters::ShowEngineRotation(int VehN) double TMoverParameters::ShowEngineRotation(int VehN)
{ // pokazywanie obrotów silnika, również dwóch dalszych pojazdów (3×SN61) { // Zwraca wartość prędkości obrotowej silnika wybranego pojazdu. Do 3 pojazdów (3×SN61).
int b; int b;
switch (VehN) switch (VehN)
{ // numer obrotomierza { // numer obrotomierza
@@ -1570,7 +1568,7 @@ void TMoverParameters::ConverterCheck()
}; };
int TMoverParameters::ShowCurrent(int AmpN) int TMoverParameters::ShowCurrent(int AmpN)
{ // odczyt amperażu { // Odczyt poboru prądu na podanym amperomierzu
switch (EngineType) switch (EngineType)
{ {
case ElectricInductionMotor: case ElectricInductionMotor:
@@ -2927,6 +2925,7 @@ void TMoverParameters::UpdateBrakePressure(double dt)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160712 // Q: 20160712
// Obliczanie pracy sprężarki
// ************************************************************************************************* // *************************************************************************************************
void TMoverParameters::CompressorCheck(double dt) void TMoverParameters::CompressorCheck(double dt)
{ {
@@ -2940,24 +2939,21 @@ void TMoverParameters::CompressorCheck(double dt)
{ {
if (Compressor < MaxCompressor) if (Compressor < MaxCompressor)
if ((EngineType == DieselElectric) && (CompressorPower > 0)) if ((EngineType == DieselElectric) && (CompressorPower > 0))
CompressedVolume = CompressedVolume + CompressedVolume += dt * CompressorSpeed *
dt * CompressorSpeed * (2 * MaxCompressor - Compressor) / (2 * MaxCompressor - Compressor) / MaxCompressor *
MaxCompressor * (DElist[MainCtrlPos].RPM / (DElist[MainCtrlPos].RPM / DElist[MainCtrlPosNo].RPM);
DElist[MainCtrlPosNo].RPM);
else else
{ {
CompressedVolume = CompressedVolume +=
CompressedVolume +
dt * CompressorSpeed * (2 * MaxCompressor - Compressor) / MaxCompressor; dt * CompressorSpeed * (2 * MaxCompressor - Compressor) / MaxCompressor;
TotalCurrent = TotalCurrent += 0.0015
0.0015 * * Voltage; // tymczasowo tylko obciążenie sprężarki, tak z 5A na sprężarkę
Voltage; // tymczasowo tylko obciążenie sprężarki, tak z 5A na sprężarkę
} }
else else
{ {
CompressedVolume = CompressedVolume * 0.8; CompressedVolume = CompressedVolume * 0.8;
SetFlag(SoundFlag, sound_relay); SetFlag(SoundFlag, sound_relay | sound_loud);
SetFlag(SoundFlag, sound_loud); // SetFlag(SoundFlag, sound_loud);
} }
} }
} }
@@ -2984,8 +2980,8 @@ void TMoverParameters::CompressorCheck(double dt)
CompressorFlag = false; // bez tamtego członu nie zadziała CompressorFlag = false; // bez tamtego członu nie zadziała
} }
else else
CompressorFlag = ((CompressorAllow) && CompressorFlag = (CompressorAllow) &&
((ConverterFlag) || (CompressorPower == 0)) && (Mains)); ((ConverterFlag) || (CompressorPower == 0)) && (Mains);
if (Compressor > if (Compressor >
MaxCompressor) // wyłącznik ciśnieniowy jest niezależny od sposobu zasilania MaxCompressor) // wyłącznik ciśnieniowy jest niezależny od sposobu zasilania
CompressorFlag = false; CompressorFlag = false;
@@ -3013,8 +3009,8 @@ void TMoverParameters::CompressorCheck(double dt)
CompressorFlag = false; // bez tamtego członu nie zadziała CompressorFlag = false; // bez tamtego członu nie zadziała
} }
else else
CompressorFlag = ((CompressorAllow) && CompressorFlag = (CompressorAllow) &&
((ConverterFlag) || (CompressorPower == 0)) && (Mains)); ((ConverterFlag) || (CompressorPower == 0)) && (Mains);
if (CompressorFlag) // jeśli została załączona if (CompressorFlag) // jeśli została załączona
LastSwitchingTime = 0; // to trzeba ograniczyć ponowne włączenie LastSwitchingTime = 0; // to trzeba ograniczyć ponowne włączenie
} }
@@ -3024,28 +3020,25 @@ void TMoverParameters::CompressorCheck(double dt)
// Connected.CompressorFlag:=CompressorFlag; // Connected.CompressorFlag:=CompressorFlag;
if (CompressorFlag) if (CompressorFlag)
if ((EngineType == DieselElectric) && (CompressorPower > 0)) if ((EngineType == DieselElectric) && (CompressorPower > 0))
CompressedVolume = CompressedVolume + CompressedVolume += dt * CompressorSpeed * (2 * MaxCompressor - Compressor) /
dt * CompressorSpeed * (2 * MaxCompressor - Compressor) /
MaxCompressor * MaxCompressor *
(DElist[MainCtrlPos].RPM / DElist[MainCtrlPosNo].RPM); (DElist[MainCtrlPos].RPM / DElist[MainCtrlPosNo].RPM);
else else
{ {
CompressedVolume = CompressedVolume +=
CompressedVolume +
dt * CompressorSpeed * (2 * MaxCompressor - Compressor) / MaxCompressor; dt * CompressorSpeed * (2 * MaxCompressor - Compressor) / MaxCompressor;
if ((CompressorPower == 5) && (Couplers[1].Connected != NULL)) if ((CompressorPower == 5) && (Couplers[1].Connected != NULL))
Couplers[1].Connected->TotalCurrent = Couplers[1].Connected->TotalCurrent +=
0.0015 * Couplers[1].Connected->Voltage; // tymczasowo tylko obciążenie 0.0015 * Couplers[1].Connected->Voltage; // tymczasowo tylko obciążenie
// sprężarki, tak z 5A na // sprężarki, tak z 5A na
// sprężarkę // sprężarkę
else if ((CompressorPower == 4) && (Couplers[0].Connected != NULL)) else if ((CompressorPower == 4) && (Couplers[0].Connected != NULL))
Couplers[0].Connected->TotalCurrent = Couplers[0].Connected->TotalCurrent +=
0.0015 * Couplers[0].Connected->Voltage; // tymczasowo tylko obciążenie 0.0015 * Couplers[0].Connected->Voltage; // tymczasowo tylko obciążenie
// sprężarki, tak z 5A na // sprężarki, tak z 5A na
// sprężarkę // sprężarkę
else else
TotalCurrent = TotalCurrent += 0.0015 *
0.0015 *
Voltage; // tymczasowo tylko obciążenie sprężarki, tak z 5A na sprężarkę Voltage; // tymczasowo tylko obciążenie sprężarki, tak z 5A na sprężarkę
} }
} }
@@ -3263,11 +3256,11 @@ void TMoverParameters::UpdatePipePressure(double dt)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160713 // Q: 20160713
// Aktualizacja ciśnienia w przewodzie zasilającym
// ************************************************************************************************* // *************************************************************************************************
void TMoverParameters::UpdateScndPipePressure(double dt) void TMoverParameters::UpdateScndPipePressure(double dt)
{ {
const Spz = 0.5067; const double Spz = 0.5067;
// T_MoverParameters *c;
TMoverParameters *c; TMoverParameters *c;
double dv1, dv2, dV; double dv1, dv2, dV;
@@ -3279,7 +3272,7 @@ void TMoverParameters::UpdateScndPipePressure(double dt)
if (TestFlag(Couplers[0].CouplingFlag, ctrain_scndpneumatic)) if (TestFlag(Couplers[0].CouplingFlag, ctrain_scndpneumatic))
{ {
c = Couplers[0].Connected; // skrot c = Couplers[0].Connected; // skrot
dv1 = 0.5 * dt * PF(ScndPipePress, c->ScndPipePress, Spz * 0.75, 0.25); dv1 = 0.5 * dt * PF(ScndPipePress, c->ScndPipePress, Spz * 0.75);
if (dv1 * dv1 > 0.00000000000001) if (dv1 * dv1 > 0.00000000000001)
c->Physic_ReActivation(); c->Physic_ReActivation();
c->Pipe2->Flow(-dv1); c->Pipe2->Flow(-dv1);
@@ -3289,7 +3282,7 @@ void TMoverParameters::UpdateScndPipePressure(double dt)
if (TestFlag(Couplers[1].CouplingFlag, ctrain_scndpneumatic)) if (TestFlag(Couplers[1].CouplingFlag, ctrain_scndpneumatic))
{ {
c = Couplers[1].Connected; // skrot c = Couplers[1].Connected; // skrot
dv2 = 0.5 * dt * PF(ScndPipePress, c->ScndPipePress, Spz * 0.75, 0.25); dv2 = 0.5 * dt * PF(ScndPipePress, c->ScndPipePress, Spz * 0.75);
if (dv2 * dv2 > 0.00000000000001) if (dv2 * dv2 > 0.00000000000001)
c->Physic_ReActivation(); c->Physic_ReActivation();
c->Pipe2->Flow(-dv2); c->Pipe2->Flow(-dv2);
@@ -3299,7 +3292,7 @@ void TMoverParameters::UpdateScndPipePressure(double dt)
(TestFlag(Couplers[1].CouplingFlag, ctrain_scndpneumatic))) (TestFlag(Couplers[1].CouplingFlag, ctrain_scndpneumatic)))
{ {
dV = 0.00025 * dt * PF(Couplers[0].Connected->ScndPipePress, dV = 0.00025 * dt * PF(Couplers[0].Connected->ScndPipePress,
Couplers[1].Connected->ScndPipePress, Spz * 0.25, 0.25); Couplers[1].Connected->ScndPipePress, Spz * 0.25);
Couplers[0].Connected->Pipe2->Flow(+dV); Couplers[0].Connected->Pipe2->Flow(+dV);
Couplers[1].Connected->Pipe2->Flow(-dV); Couplers[1].Connected->Pipe2->Flow(-dV);
} }
@@ -3308,8 +3301,8 @@ void TMoverParameters::UpdateScndPipePressure(double dt)
if (((Compressor > ScndPipePress) && (CompressorSpeed > 0.0001)) || (TrainType == dt_EZT)) if (((Compressor > ScndPipePress) && (CompressorSpeed > 0.0001)) || (TrainType == dt_EZT))
{ {
dV = PF(Compressor, ScndPipePress, Spz, 0.25) * dt; dV = PF(Compressor, ScndPipePress, Spz) * dt;
CompressedVolume = CompressedVolume + dV / 1000; CompressedVolume += dV / 1000;
Pipe2->Flow(-dV); Pipe2->Flow(-dV);
} }
@@ -4365,11 +4358,11 @@ double TMoverParameters::TractionForce(double dt)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160713 // Q: 20160713
//Obliczenie predkości obrotowej kół???
// ************************************************************************************************* // *************************************************************************************************
double TMoverParameters::ComputeRotatingWheel(double WForce, double dt, double n) double TMoverParameters::ComputeRotatingWheel(double WForce, double dt, double n)
{ {
double newn, eps; double newn, eps;
bool CRW;
if ((n == 0) && (WForce * Sign(V) < 0)) if ((n == 0) && (WForce * Sign(V) < 0))
newn = 0; newn = 0;
else else
@@ -4379,46 +4372,45 @@ double TMoverParameters::ComputeRotatingWheel(double WForce, double dt, double n
if ((newn * n <= 0) && (eps * n < 0)) if ((newn * n <= 0) && (eps * n < 0))
newn = 0; newn = 0;
} }
CRW = newn; return newn;
return CRW;
} }
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160713 // Q: 20160713
// Sprawdzenie bezpiecznika nadmiarowego
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::FuseFlagCheck(void) bool TMoverParameters::FuseFlagCheck(void)
{ {
int b;
bool FFC; bool FFC;
FFC = false; FFC = false;
if (Power > 0.01) if (Power > 0.01)
FFC = FuseFlag; FFC = FuseFlag;
// Q: TODO: zakomentowalem bo nie widzi funkcji else // pobor pradu jezeli niema mocy
//- else //pobor pradu jezeli niema mocy for (int b = 0; b < 2; b++)
//- for (b=0; b < 1; b++) if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll))
//- if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll)) if (Couplers[b].Connected->Power > 0.01)
//- if (Couplers[b].Connected->Power > 0.01) FFC = Couplers[b].Connected->FuseFlagCheck();
//- FFC = Couplers[b].Connected->FuseFlagCheck();
return FFC; return FFC;
} }
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160713 // Q: 20160713
// Załączenie bezpiecznika nadmiarowego
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::FuseOn(void) bool TMoverParameters::FuseOn(void)
{ {
bool FO = false; bool FO = false;
if ((MainCtrlPos == 0) && (ScndCtrlPos == 0) && (TrainType != dt_ET40) && Mains) if ((MainCtrlPos == 0) && (ScndCtrlPos == 0) && (TrainType != dt_ET40) &&
((Mains) || (TrainType != dt_EZT)) && (!TestFlag(EngDmgFlag, 1)))
{ // w ET40 jest blokada nastawnika, ale czy działa dobrze? { // w ET40 jest blokada nastawnika, ale czy działa dobrze?
SendCtrlToNext("FuseSwitch", 1, CabNo); SendCtrlToNext("FuseSwitch", 1, CabNo);
if (((EngineType == ElectricSeriesMotor) || ((EngineType == DieselElectric))) && FuseFlag) if (((EngineType == ElectricSeriesMotor) || ((EngineType == DieselElectric))) && FuseFlag)
{ {
FuseFlag = false; // wlaczenie ponowne obwodu FuseFlag = false; // wlaczenie ponowne obwodu
FO = true; FO = true;
SetFlag(SoundFlag, sound_relay); SetFlag(SoundFlag, sound_relay | sound_loud);
SetFlag(SoundFlag, sound_loud);
} }
} }
return FO; return FO;
@@ -4426,6 +4418,7 @@ bool TMoverParameters::FuseOn(void)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160713 // Q: 20160713
// Wyłączenie bezpiecznika nadmiarowego
// ************************************************************************************************* // *************************************************************************************************
void TMoverParameters::FuseOff(void) void TMoverParameters::FuseOff(void)
{ {
@@ -4433,18 +4426,18 @@ void TMoverParameters::FuseOff(void)
{ {
FuseFlag = true; FuseFlag = true;
EventFlag = true; EventFlag = true;
SetFlag(SoundFlag, sound_relay); SetFlag(SoundFlag, sound_relay | sound_loud);
SetFlag(SoundFlag, sound_loud);
} }
} }
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160713 // Q: 20160713
// Przeliczenie prędkości liniowej na obrotową
// ************************************************************************************************* // *************************************************************************************************
double TMoverParameters::v2n(void) double TMoverParameters::v2n(void)
{ {
// przelicza predkosc liniowa na obrotowa // przelicza predkosc liniowa na obrotowa
const dmgn = 0.5; const double dmgn = 0.5;
double n, deltan; double n, deltan;
n = V / (PI * WheelDiameter); // predkosc obrotowa wynikajaca z liniowej [obr/s] n = V / (PI * WheelDiameter); // predkosc obrotowa wynikajaca z liniowej [obr/s]
@@ -4469,6 +4462,7 @@ double TMoverParameters::v2n(void)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160714 // Q: 20160714
// Oblicza moment siły wytwarzany przez silnik
// ************************************************************************************************* // *************************************************************************************************
double TMoverParameters::Momentum(double I) double TMoverParameters::Momentum(double I)
{ {
@@ -4487,6 +4481,7 @@ double TMoverParameters::Momentum(double I)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160714 // Q: 20160714
// Oblicza moment siły do sterowania wzbudzeniem
// ************************************************************************************************* // *************************************************************************************************
double TMoverParameters::MomentumF(double I, double Iw, int SCP) double TMoverParameters::MomentumF(double I, double Iw, int SCP)
{ {
@@ -4498,6 +4493,7 @@ double TMoverParameters::MomentumF(double I, double Iw, int SCP)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160713 // Q: 20160713
// Odłączenie uszkodzonych silników
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::CutOffEngine(void) bool TMoverParameters::CutOffEngine(void)
{ {
@@ -4515,6 +4511,7 @@ bool TMoverParameters::CutOffEngine(void)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160713 // Q: 20160713
// Przełączenie wysoki / niski prąd rozruchu
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::MaxCurrentSwitch(bool State) bool TMoverParameters::MaxCurrentSwitch(bool State)
{ {
@@ -4545,6 +4542,7 @@ bool TMoverParameters::MaxCurrentSwitch(bool State)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160713 // Q: 20160713
// Przełączenie wysoki / niski prąd rozruchu automatycznego
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::MinCurrentSwitch(bool State) bool TMoverParameters::MinCurrentSwitch(bool State)
{ {
@@ -4571,26 +4569,27 @@ bool TMoverParameters::MinCurrentSwitch(bool State)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160713 // Q: 20160713
// Sprawdzenie wskaźnika jazdy na oporach
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::ResistorsFlagCheck(void) bool TMoverParameters::ResistorsFlagCheck(void)
{ {
int b;
bool RFC = false; bool RFC = false;
if (Power > 0.01) if (Power > 0.01)
RFC = ResistorsFlag; RFC = ResistorsFlag;
// Q: TODO: zakomentowalem bo nie widzi funkcji, do czasu przenesienia TCoupling do mover.h
else // pobor pradu jezeli niema mocy else // pobor pradu jezeli niema mocy
RFC = false; // po przeniesieniu usunac te linie {
//- for (b=0; b<1; b++) for (int b = 0; b < 2; b++)
//- if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll)) if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll))
//- if (Couplers[b].Connected->Power > 0.01) if (Couplers[b].Connected->Power > 0.01)
//- RFC = Couplers[b].Connected->ResistorsFlagCheck(); RFC = Couplers[b].Connected->ResistorsFlagCheck();
}
return RFC; return RFC;
} }
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160713 // Q: 20160713
// Włączenie / wyłączenie automatycznego rozruchu
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::AutoRelaySwitch(bool State) bool TMoverParameters::AutoRelaySwitch(bool State)
{ {
@@ -4609,6 +4608,7 @@ bool TMoverParameters::AutoRelaySwitch(bool State)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160724 // Q: 20160724
// Sprawdzenie warunków pracy automatycznego rozruchu
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::AutoRelayCheck(void) bool TMoverParameters::AutoRelayCheck(void)
@@ -4619,7 +4619,8 @@ bool TMoverParameters::AutoRelayCheck(void)
// Ra 2014-06: dla SN61 nie działa prawidłowo // Ra 2014-06: dla SN61 nie działa prawidłowo
// rozlaczanie stycznikow liniowych // rozlaczanie stycznikow liniowych
if ((!Mains) || (FuseFlag) || (MainCtrlPos == 0) || (BrakePress > 2.1) || if ((!Mains) || (FuseFlag) || (MainCtrlPos == 0) ||
((BrakePress > 2.1) && (TrainType != dt_EZT)) ||
(ActiveDir == 0)) // hunter-111211: wylacznik cisnieniowy (ActiveDir == 0)) // hunter-111211: wylacznik cisnieniowy
{ {
StLinFlag = false; // yBARC - rozlaczenie stycznikow liniowych StLinFlag = false; // yBARC - rozlaczenie stycznikow liniowych
@@ -4632,11 +4633,11 @@ bool TMoverParameters::AutoRelayCheck(void)
} }
} }
ARFASI2 = ((!AutoRelayFlag) || ((MotorParam[ScndCtrlActualPos].AutoSwitch) && 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)) || ARFASI = (!AutoRelayFlag) || ((RList[MainCtrlActualPos].AutoSwitch) && (abs(Im) < Imin)) ||
((!RList[MainCtrlActualPos].AutoSwitch) && ((!RList[MainCtrlActualPos].AutoSwitch) &&
(RList[MainCtrlActualPos].Relay < MainCtrlPos))); // wszystkie warunki w jednym (RList[MainCtrlActualPos].Relay < MainCtrlPos)); // wszystkie warunki w jednym
// brak PSR na tej pozycji działa PSR i prąd poniżej progu // 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 // 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 // chodzi w tym wszystkim o to, żeby można było zatrzymać rozruch na
@@ -4650,7 +4651,7 @@ bool TMoverParameters::AutoRelayCheck(void)
((ScndCtrlActualPos > 0) || (ScndCtrlPos > 0)) && ((ScndCtrlActualPos > 0) || (ScndCtrlPos > 0)) &&
(!(CoupledCtrl) || (RList[MainCtrlActualPos].Relay == MainCtrlPos))) (!(CoupledCtrl) || (RList[MainCtrlActualPos].Relay == MainCtrlPos)))
{ // zmieniaj scndctrlactualpos { // zmieniaj scndctrlactualpos
//{ //scnd bez samoczynnego rozruchu // scnd bez samoczynnego rozruchu
if (ScndCtrlActualPos < ScndCtrlPos) if (ScndCtrlActualPos < ScndCtrlPos)
{ {
if ((LastRelayTime > CtrlDelay) && (ARFASI2)) if ((LastRelayTime > CtrlDelay) && (ARFASI2))
@@ -4669,18 +4670,17 @@ bool TMoverParameters::AutoRelayCheck(void)
} }
else else
OK = false; OK = false;
// }
} }
else else
{ // zmieniaj mainctrlactualpos { // zmieniaj mainctrlactualpos
if ((ActiveDir < 0) && (TrainType != dt_PseudoDiesel)) if ((ActiveDir < 0) && (TrainType != dt_PseudoDiesel))
if (RList[MainCtrlActualPos + 1].Bn > 1) if (RList[MainCtrlActualPos + 1].Bn > 1)
{ {
OK = false; return false; // nie poprawiamy przy konwersji
// return ARC;// bbylo exit; //Ra: to powoduje, że EN57 nie wyłącza się przy // return ARC;// bbylo exit; //Ra: to powoduje, że EN57 nie wyłącza się przy
// IminLo // IminLo
} }
{ // main bez samoczynnego rozruchu // main bez samoczynnego rozruchu
if ((RList[MainCtrlActualPos].Relay < MainCtrlPos) || if ((RList[MainCtrlActualPos].Relay < MainCtrlPos) ||
(RList[MainCtrlActualPos + 1].Relay == MainCtrlPos) || (RList[MainCtrlActualPos + 1].Relay == MainCtrlPos) ||
@@ -4693,8 +4693,7 @@ bool TMoverParameters::AutoRelayCheck(void)
// MainCtrlActualPos:=MainCtrlPos; //hunter-111012: // MainCtrlActualPos:=MainCtrlPos; //hunter-111012:
// szybkie wchodzenie na bezoporowa (303E) // szybkie wchodzenie na bezoporowa (303E)
OK = true; OK = true;
SetFlag(SoundFlag, sound_manyrelay); SetFlag(SoundFlag, sound_manyrelay | sound_loud);
SetFlag(SoundFlag, sound_loud);
} }
else if ((LastRelayTime > CtrlDelay) && (ARFASI)) else if ((LastRelayTime > CtrlDelay) && (ARFASI))
{ {
@@ -4726,11 +4725,9 @@ bool TMoverParameters::AutoRelayCheck(void)
// hunter-111211: poprawki // hunter-111211: poprawki
if (MainCtrlActualPos > 0) if (MainCtrlActualPos > 0)
if ((RList[MainCtrlActualPos].R == 0) && if ((RList[MainCtrlActualPos].R == 0) &&
(!(MainCtrlActualPos == (!(MainCtrlActualPos == MainCtrlPosNo))) // wejscie na bezoporowa
MainCtrlPosNo))) // wejscie na bezoporowa
{ {
SetFlag(SoundFlag, sound_manyrelay); SetFlag(SoundFlag, sound_manyrelay | sound_loud);
SetFlag(SoundFlag, sound_loud);
} }
else if ((RList[MainCtrlActualPos].R > 0) && else if ((RList[MainCtrlActualPos].R > 0) &&
(RList[MainCtrlActualPos - 1].R == (RList[MainCtrlActualPos - 1].R ==
@@ -4778,15 +4775,14 @@ bool TMoverParameters::AutoRelayCheck(void)
OK = false; OK = false;
} }
} }
}
else // not StLinFlag else // not StLinFlag
{ {
OK = false; OK = false;
// ybARC - tutaj sa wszystkie warunki, jakie musza byc spelnione, zeby mozna byla // ybARC - tutaj sa wszystkie warunki, jakie musza byc spelnione, zeby mozna byla
// zalaczyc styczniki liniowe // zalaczyc styczniki liniowe
if (((MainCtrlPos == 1) || ((TrainType == dt_EZT) && (MainCtrlPos > 0))) && if (((MainCtrlPos == 1) || ((TrainType == dt_EZT) && (MainCtrlPos > 0))) &&
(!FuseFlag) && (Mains) && /*(BrakePress < 1.0) &&*/ (MainCtrlActualPos == 0) && (!FuseFlag) && (Mains) && ((BrakePress < 1.0) || (TrainType == dt_EZT)) &&
(ActiveDir != 0)) (MainCtrlActualPos == 0) && (ActiveDir != 0))
{ //^^ TODO: sprawdzic BUG, prawdopodobnie w CreateBrakeSys() { //^^ TODO: sprawdzic BUG, prawdopodobnie w CreateBrakeSys()
DelayCtrlFlag = true; DelayCtrlFlag = true;
if (LastRelayTime >= InitialCtrlDelay) if (LastRelayTime >= InitialCtrlDelay)
@@ -4794,8 +4790,7 @@ bool TMoverParameters::AutoRelayCheck(void)
StLinFlag = true; // ybARC - zalaczenie stycznikow liniowych StLinFlag = true; // ybARC - zalaczenie stycznikow liniowych
MainCtrlActualPos = 1; MainCtrlActualPos = 1;
DelayCtrlFlag = false; DelayCtrlFlag = false;
SetFlag(SoundFlag, sound_relay); SetFlag(SoundFlag, sound_relay | sound_loud);
SetFlag(SoundFlag, sound_loud);
OK = true; OK = true;
} }
} }
@@ -4932,6 +4927,7 @@ bool TMoverParameters::PantRear(bool State)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160715 // Q: 20160715
// Zmienia parametr do którego dąży sprzęgło
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::dizel_EngageSwitch(double state) bool TMoverParameters::dizel_EngageSwitch(double state)
{ {
@@ -4947,12 +4943,12 @@ bool TMoverParameters::dizel_EngageSwitch(double state)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160715 // Q: 20160715
// Zmienia parametr do którego dąży sprzęgło
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::dizel_EngageChange(double dt) bool TMoverParameters::dizel_EngageChange(double dt)
{ {
// zmienia parametr do ktorego dazy sprzeglo const double engagedownspeed = 0.9;
const engagedownspeed = 0.9; const double engageupspeed = 0.5;
const engageupspeed = 0.5;
double engagespeed; // OK:boolean; double engagespeed; // OK:boolean;
bool DEC; bool DEC;
@@ -4983,6 +4979,7 @@ bool TMoverParameters::dizel_EngageChange(double dt)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160715 // Q: 20160715
// Automatyczna zmiana biegów gdy prędkość przekroczy widełki
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::dizel_AutoGearCheck(void) bool TMoverParameters::dizel_AutoGearCheck(void)
{ {
@@ -5035,8 +5032,10 @@ bool TMoverParameters::dizel_AutoGearCheck(void)
{ {
case 1: case 1:
dizel_EngageSwitch(0.5); dizel_EngageSwitch(0.5);
break;
case 2: case 2:
dizel_EngageSwitch(1.0); dizel_EngageSwitch(1.0);
break;
default: default:
dizel_EngageSwitch(0.0); dizel_EngageSwitch(0.0);
} }
@@ -5052,10 +5051,11 @@ bool TMoverParameters::dizel_AutoGearCheck(void)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160715 // Q: 20160715
// Aktualizacja stanu silnika
// ************************************************************************************************* // *************************************************************************************************
bool TMoverParameters::dizel_Update(double dt) bool TMoverParameters::dizel_Update(double dt)
{ // odświeża informacje o silniku {
const fillspeed = 2; const double fillspeed = 2;
bool DU; bool DU;
// dizel_Update:=false; // dizel_Update:=false;
@@ -5077,9 +5077,10 @@ bool TMoverParameters::dizel_Update(double dt)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160715 // Q: 20160715
// oblicza napelnienie, uzwglednia regulator obrotow
// ************************************************************************************************* // *************************************************************************************************
double TMoverParameters::dizel_fillcheck(int mcp) double TMoverParameters::dizel_fillcheck(int mcp)
{ // oblicza napelnienie, uzwglednia regulator obrotow {
double realfill, nreg; double realfill, nreg;
realfill = 0; realfill = 0;
@@ -5098,11 +5099,13 @@ double TMoverParameters::dizel_fillcheck(int mcp)
case 0: case 0:
case 1: case 1:
nreg = dizel_nmin; nreg = dizel_nmin;
break;
case 2: case 2:
if (dizel_automaticgearstatus == 0) if (dizel_automaticgearstatus == 0)
nreg = dizel_nmax; nreg = dizel_nmax;
else else
nreg = dizel_nmin; nreg = dizel_nmin;
break;
default: default:
realfill = 0; // sluczaj realfill = 0; // sluczaj
} }
@@ -5123,11 +5126,11 @@ double TMoverParameters::dizel_fillcheck(int mcp)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160715 // Q: 20160715
// Oblicza moment siły wytwarzany przez silnik spalinowy
// ************************************************************************************************* // *************************************************************************************************
double TMoverParameters::dizel_Momentum(double dizel_fill, double n, double dt) double TMoverParameters::dizel_Momentum(double dizel_fill, double n, double dt)
{ // liczy moment sily wytwarzany przez silnik spalinowy} { // liczy moment sily wytwarzany przez silnik spalinowy}
double Moment, enMoment, eps, newn, friction; double Moment, enMoment, eps, newn, friction;
double DM;
// friction =dizel_engagefriction*(11-2*random)/10; // friction =dizel_engagefriction*(11-2*random)/10;
friction = dizel_engagefriction; friction = dizel_engagefriction;
@@ -5177,11 +5180,10 @@ double TMoverParameters::dizel_Momentum(double dizel_fill, double n, double dt)
} }
enrot = newn; enrot = newn;
} }
DM = Moment;
if ((enrot == 0) && (!dizel_enginestart)) if ((enrot == 0) && (!dizel_enginestart))
Mains = false; Mains = false;
return DM; return Moment;
} }
// ************************************************************************************************* // *************************************************************************************************
@@ -7988,6 +7990,7 @@ bool TMoverParameters::RunInternalCommand(void)
// ************************************************************************************************* // *************************************************************************************************
// Q: 20160714 // Q: 20160714
// Zwraca wartość natężenia prądu na wybranym amperomierzu. Podfunkcja do ShowCurrent.
// ************************************************************************************************* // *************************************************************************************************
int TMoverParameters::ShowCurrentP(int AmpN) int TMoverParameters::ShowCurrentP(int AmpN)
{ {
@@ -8013,11 +8016,15 @@ int TMoverParameters::ShowCurrentP(int AmpN)
return floor(abs(Itot)); return floor(abs(Itot));
} }
else // pobor pradu jezeli niema mocy else // pobor pradu jezeli niema mocy
{
int current = 0;
for (b = 0; b < 1; b++) for (b = 0; b < 1; b++)
// with Couplers[b] do // with Couplers[b] do
if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll)) if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll))
if (Couplers[b].Connected->Power > 0.01) if (Couplers[b].Connected->Power > 0.01)
return Couplers[b].Connected->ShowCurrent(AmpN); current = Couplers[b].Connected->ShowCurrent(AmpN);
return current;
}
} }

6
McZapkie/hamulce.cpp
View File

@@ -323,6 +323,12 @@ double TBrake::GetBCP()
return BrakeCyl->P(); return BrakeCyl->P();
} }
// ciśnienie sterujące hamowaniem elektro-dynamicznym
double TBrake::GetEDBCP()
{
return 0;
}
// cisnienie zbiornika pomocniczego // cisnienie zbiornika pomocniczego
double TBrake::GetBRP() double TBrake::GetBRP()
{ {

5
McZapkie/hamulce.h
View File

@@ -213,6 +213,7 @@ Knorr/West EP -
double GetBCF(); //sila tlokowa z tloka double GetBCF(); //sila tlokowa z tloka
virtual double GetHPFlow(double HP, double dt); //przeplyw - 8 bar virtual double GetHPFlow(double HP, double dt); //przeplyw - 8 bar
double GetBCP(); //cisnienie cylindrow hamulcowych 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 GetBRP(); //cisnienie zbiornika pomocniczego
double GetVRP(); //cisnienie komory wstepnej rozdzielacza double GetVRP(); //cisnienie komory wstepnej rozdzielacza
virtual double GetCRP(); //cisnienie zbiornika sterujacego virtual double GetCRP(); //cisnienie zbiornika sterujacego
@@ -228,6 +229,8 @@ Knorr/West EP -
void SetASBP(double Press); //ustalenie cisnienia pp void SetASBP(double Press); //ustalenie cisnienia pp
virtual void ForceEmptiness(); virtual void ForceEmptiness();
int GetSoundFlag(); int GetSoundFlag();
virtual void SetED(double EDstate) {}; //stan hamulca ED do luzowania
// procedure // procedure
}; };
@@ -382,7 +385,7 @@ Knorr/West EP -
double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG 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 GetHPFlow(double HP, double dt)/*override*/; //przeplyw - 8 bar
virtual double GetEDBCP(); //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED w EP09 virtual double GetEDBCP(); //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED w EP09
void SetED(double EDstate); //stan hamulca ED do luzowania virtual void SetED(double EDstate); //stan hamulca ED do luzowania
inline TLSt(double i_mbp, double i_bcr, double i_bcd, double i_brc, 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, int i_bcn, int i_BD, int i_mat, int i_ba, int i_nbpa,