mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-03-22 15:05:03 +01:00
c84bf7319b
2. Możliwość zdefiniowania koloru tła ekranu ładowania w eu07.ini. 3. Dodanie logowania ruchu ramek WM_COPYDATA do oddzielnego pliku. 4. Dodana ramka skrócona aktywnych AI. 5. Dodana ramka sterowania uszkodzeniami pojazdów. 6. Dodanie kręciołka od świateł (w tym trakcja wielokrotna). 7. Rozbudowa asynchronów, m.in. tempomat, zadawanie siły (w kN), przeciwpoślizg, czyste ED itd. 8. Dodanie animacji drtzwi odskokowo-przesuwnych. 9. Dodanie możliwości uszkadzania pojazdów (EN57). 10. Uruchomienie sprzęgu WN, zwłaszcza w asynchronach - do przejrzenia logowanie braków napięcia. 11. Wyłączanie radiostopu przez wyłączanie radia, a nie przez ruch zaworem maszynisty. 12. Usunięcie wyłącznika ciśnieniowego w EN57 (proteza, trzeba zrobić wpis na to). 13. Wstępna wersja hamowania rekuperacyjnego wraz z przechodzeniem na hamowanie oporowe. 14. Cała masa nowych zmiennych stanu dostępna dla ekranu (Pythona). 15. Nowa stara smuga z dawnego SPKSu. 16. Inne, które mogłem zapomnieć lub nie uszczegółowić. 17. Poprawione wyświetlanie haslera
656 lines
27 KiB
C++
656 lines
27 KiB
C++
/*
|
||
This Source Code Form is subject to the
|
||
terms of the Mozilla Public License, v.
|
||
2.0. If a copy of the MPL was not
|
||
distributed with this file, You can
|
||
obtain one at
|
||
http://mozilla.org/MPL/2.0/.
|
||
*/
|
||
|
||
#include "Mover.h"
|
||
//---------------------------------------------------------------------------
|
||
#pragma package(smart_init)
|
||
// Ra: tu nale¿y przenosiæ funcje z mover.pas, które nie s¹ z niego wywo³ywane.
|
||
// Jeœli jakieœ zmienne nie s¹ u¿ywane w mover.pas, te¿ mo¿na je przenosiæ.
|
||
// Przeniesienie wszystkiego na raz zrobi³o by zbyt wielki chaos do ogarniêcia.
|
||
|
||
const dEpsilon = 0.01; // 1cm (zale¿y od typu sprzêgu...)
|
||
|
||
TMoverParameters::TMoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit,
|
||
int LoadInitial, AnsiString LoadTypeInitial, int Cab)
|
||
: T_MoverParameters(VelInitial, TypeNameInit, NameInit, LoadInitial, LoadTypeInitial, Cab)
|
||
{ // g³ówny konstruktor
|
||
DimHalf.x = 0.5 * Dim.W; // po³owa szerokoœci, OX jest w bok?
|
||
DimHalf.y = 0.5 * Dim.L; // po³owa d³ugoœci, OY jest do przodu?
|
||
DimHalf.z = 0.5 * Dim.H; // po³owa wysokoœci, OZ jest w górê?
|
||
// BrakeLevelSet(-2); //Pascal ustawia na 0, przestawimy na odciêcie (CHK jest jeszcze nie
|
||
// wczytane!)
|
||
bPantKurek3 = true; // domyœlnie zbiornik pantografu po³¹czony jest ze zbiornikiem g³ównym
|
||
iProblem = 0; // pojazd w pe³ni gotowy do ruchu
|
||
iLights[0] = iLights[1] = 0; //œwiat³a zgaszone
|
||
};
|
||
|
||
double TMoverParameters::Distance(const TLocation &Loc1, const TLocation &Loc2,
|
||
const TDimension &Dim1, const TDimension &Dim2)
|
||
{ // zwraca odleg³oœæ pomiêdzy pojazdami (Loc1) i (Loc2) z uwzglêdnieneim ich d³ugoœci (kule!)
|
||
return hypot(Loc2.X - Loc1.X, Loc1.Y - Loc2.Y) - 0.5 * (Dim2.L + Dim1.L);
|
||
};
|
||
|
||
double TMoverParameters::Distance(const vector3 &s1, const vector3 &s2, const vector3 &d1,
|
||
const vector3 &d2){
|
||
// obliczenie odleg³oœci prostopad³oœcianów o œrodkach (s1) i (s2) i wymiarach (d1) i (d2)
|
||
// return 0.0; //bêdzie zg³aszaæ warning - funkcja do usuniêcia, chyba ¿e siê przyda...
|
||
};
|
||
|
||
double TMoverParameters::CouplerDist(Byte Coupler)
|
||
{ // obliczenie odleg³oœci pomiêdzy sprzêgami (kula!)
|
||
return Couplers[Coupler].CoupleDist =
|
||
Distance(Loc, Couplers[Coupler].Connected->Loc, Dim,
|
||
Couplers[Coupler].Connected->Dim); // odleg³oœæ pomiêdzy sprzêgami (kula!)
|
||
};
|
||
|
||
bool TMoverParameters::Attach(Byte ConnectNo, Byte ConnectToNr, TMoverParameters *ConnectTo,
|
||
Byte 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
|
||
// sk³adu
|
||
if (ConnectTo) // jeœli nie pusty
|
||
{
|
||
if (ConnectToNr != 2)
|
||
Couplers[ConnectNo].ConnectedNr = ConnectToNr; // 2=nic nie pod³¹czone
|
||
TCouplerType ct = ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr]
|
||
.CouplerType; // typ sprzêgu pod³¹czanego pojazdu
|
||
Couplers[ConnectNo].Connected =
|
||
ConnectTo; // tak podpi¹æ (do siebie) zawsze mo¿na, najwy¿ej bêdzie wirtualny
|
||
CouplerDist(ConnectNo); // przeliczenie odleg³oœci pomiêdzy sprzêgami
|
||
if (CouplingType == ctrain_virtual)
|
||
return false; // wirtualny wiêcej nic nie robi
|
||
if (Forced ? true : ((Couplers[ConnectNo].CoupleDist <= dEpsilon) &&
|
||
(Couplers[ConnectNo].CouplerType != NoCoupler) &&
|
||
(Couplers[ConnectNo].CouplerType == ct)))
|
||
{ // stykaja sie zderzaki i kompatybilne typy sprzegow, chyba ¿e ³¹czenie na starcie
|
||
if (Couplers[ConnectNo].CouplingFlag ==
|
||
ctrain_virtual) // jeœli wczeœniej nie by³o po³¹czone
|
||
{ // ustalenie z której strony rysowaæ sprzêg
|
||
Couplers[ConnectNo].Render = true; // tego rysowaæ
|
||
ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].Render = false; // a tego nie
|
||
};
|
||
Couplers[ConnectNo].CouplingFlag = CouplingType; // ustawienie typu sprzêgu
|
||
// if (CouplingType!=ctrain_virtual) //Ra: wirtualnego nie ³¹czymy zwrotnie!
|
||
//{//jeœli ³¹czenie sprzêgiem niewirtualnym, ustawiamy po³¹czenie zwrotne
|
||
ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag = CouplingType;
|
||
ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].Connected = this;
|
||
ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].CoupleDist =
|
||
Couplers[ConnectNo].CoupleDist;
|
||
return true;
|
||
//}
|
||
// pod³¹czenie nie uda³o siê - jest wirtualne
|
||
}
|
||
}
|
||
return false; // brak pod³¹czanego pojazdu, zbyt du¿a odleg³oœæ, niezgodny typ sprzêgu, brak
|
||
// sprzêgu, brak haka
|
||
};
|
||
|
||
bool TMoverParameters::Attach(Byte ConnectNo, Byte ConnectToNr, T_MoverParameters *ConnectTo,
|
||
Byte CouplingType, bool Forced)
|
||
{ //³¹czenie do (ConnectNo) pojazdu (ConnectTo) stron¹ (ConnectToNr)
|
||
return Attach(ConnectNo, ConnectToNr, (TMoverParameters *)ConnectTo, CouplingType, Forced);
|
||
};
|
||
|
||
int TMoverParameters::DettachStatus(Byte ConnectNo)
|
||
{ // Ra: sprawdzenie, czy odleg³oœæ jest dobra do roz³¹czania
|
||
// powinny byæ 3 informacje: =0 sprzêg ju¿ roz³¹czony, <0 da siê roz³¹czyæ. >0 nie da siê
|
||
// roz³¹czyæ
|
||
if (!Couplers[ConnectNo].Connected)
|
||
return 0; // nie ma nic, to roz³¹czanie jest OK
|
||
if ((Couplers[ConnectNo].CouplingFlag & ctrain_coupler) == 0)
|
||
return -Couplers[ConnectNo].CouplingFlag; // hak nie po³¹czony - roz³¹czanie jest OK
|
||
if (TestFlag(DamageFlag, dtrain_coupling))
|
||
return -Couplers[ConnectNo].CouplingFlag; // hak urwany - roz³¹czanie jest OK
|
||
// ABu021104: zakomentowane 'and (CouplerType<>Articulated)' w warunku, nie wiem co to bylo, ale
|
||
// za to teraz dziala odczepianie... :) }
|
||
// if (CouplerType==Articulated) return false; //sprzêg nie do rozpiêcia - mo¿e byæ tylko urwany
|
||
// Couplers[ConnectNo].CoupleDist=Distance(Loc,Couplers[ConnectNo].Connected->Loc,Dim,Couplers[ConnectNo].Connected->Dim);
|
||
CouplerDist(ConnectNo);
|
||
if (Couplers[ConnectNo].CouplerType == Screw ? Couplers[ConnectNo].CoupleDist < 0.0 : true)
|
||
return -Couplers[ConnectNo].CouplingFlag; // mo¿na roz³¹czaæ, jeœli dociœniêty
|
||
return (Couplers[ConnectNo].CoupleDist > 0.2) ? -Couplers[ConnectNo].CouplingFlag :
|
||
Couplers[ConnectNo].CouplingFlag;
|
||
};
|
||
|
||
bool TMoverParameters::Dettach(Byte ConnectNo)
|
||
{ // rozlaczanie
|
||
if (!Couplers[ConnectNo].Connected)
|
||
return true; // nie ma nic, to odczepiono
|
||
// with Couplers[ConnectNo] do
|
||
int i = DettachStatus(ConnectNo); // stan sprzêgu
|
||
if (i < 0)
|
||
{ // gdy scisniete zderzaki, chyba ze zerwany sprzeg (wirtualnego nie odpinamy z drugiej strony)
|
||
// Couplers[ConnectNo].Connected=NULL; //lepiej zostawic bo przeciez trzeba kontrolowac
|
||
// zderzenia odczepionych
|
||
Couplers[ConnectNo].Connected->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag =
|
||
0; // pozostaje sprzêg wirtualny
|
||
Couplers[ConnectNo].CouplingFlag = 0; // pozostaje sprzêg wirtualny
|
||
return true;
|
||
}
|
||
else if (i > 0)
|
||
{ // od³¹czamy wê¿e i resztê, pozostaje sprzêg fizyczny, który wymaga dociœniêcia (z wirtualnym
|
||
// nic)
|
||
Couplers[ConnectNo].CouplingFlag &= ctrain_coupler;
|
||
Couplers[ConnectNo].Connected->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag =
|
||
Couplers[ConnectNo].CouplingFlag;
|
||
}
|
||
return false; // jeszcze nie roz³¹czony
|
||
};
|
||
|
||
void TMoverParameters::SetCoupleDist()
|
||
{ // przeliczenie odleg³oœci sprzêgów
|
||
if (Couplers[0].Connected)
|
||
{
|
||
CouplerDist(0);
|
||
if (CategoryFlag & 2)
|
||
{ // Ra: dla samochodów zderzanie kul to za ma³o
|
||
}
|
||
}
|
||
if (Couplers[1].Connected)
|
||
{
|
||
CouplerDist(1);
|
||
if (CategoryFlag & 2)
|
||
{ // Ra: dla samochodów zderzanie kul to za ma³o
|
||
}
|
||
}
|
||
};
|
||
|
||
bool TMoverParameters::DirectionForward()
|
||
{
|
||
if ((MainCtrlPosNo > 0) && (ActiveDir < 1) && (MainCtrlPos == 0))
|
||
{
|
||
++ActiveDir;
|
||
DirAbsolute = ActiveDir * CabNo;
|
||
if (DirAbsolute)
|
||
if (Battery) // jeœli bateria jest ju¿ za³¹czona
|
||
BatterySwitch(true); // to w ten oto durny sposób aktywuje siê CA/SHP
|
||
SendCtrlToNext("Direction", ActiveDir, CabNo);
|
||
return true;
|
||
}
|
||
else if ((ActiveDir == 1) && (MainCtrlPos == 0) && (TrainType == dt_EZT))
|
||
return MinCurrentSwitch(true); //"wysoki rozruch" EN57
|
||
return false;
|
||
};
|
||
|
||
// Nastawianie hamulców
|
||
|
||
void TMoverParameters::BrakeLevelSet(double b)
|
||
{ // ustawienie pozycji hamulca na wartoϾ (b) w zakresie od -2 do BrakeCtrlPosNo
|
||
// jedyny dopuszczalny sposób przestawienia hamulca zasadniczego
|
||
if (fBrakeCtrlPos == b)
|
||
return; // nie przeliczaæ, jak nie ma zmiany
|
||
fBrakeCtrlPos = b;
|
||
BrakeCtrlPosR = b;
|
||
if (fBrakeCtrlPos < Handle->GetPos(bh_MIN))
|
||
fBrakeCtrlPos = Handle->GetPos(bh_MIN); // odciêcie
|
||
else if (fBrakeCtrlPos > Handle->GetPos(bh_MAX))
|
||
fBrakeCtrlPos = Handle->GetPos(bh_MAX);
|
||
int x = floor(fBrakeCtrlPos); // jeœli odwo³ujemy siê do BrakeCtrlPos w poœrednich, to musi byæ
|
||
// obciête a nie zaokr¹gone
|
||
while ((x > BrakeCtrlPos) && (BrakeCtrlPos < BrakeCtrlPosNo)) // jeœli zwiêkszy³o siê o 1
|
||
if (!T_MoverParameters::IncBrakeLevelOld())
|
||
break; // wyjœcie awaryjne
|
||
while ((x < BrakeCtrlPos) && (BrakeCtrlPos >= -1)) // jeœli zmniejszy³o siê o 1
|
||
if (!T_MoverParameters::DecBrakeLevelOld())
|
||
break;
|
||
BrakePressureActual = BrakePressureTable[BrakeCtrlPos + 2]; // skopiowanie pozycji
|
||
/*
|
||
//youBy: obawiam sie, ze tutaj to nie dziala :P
|
||
//Ra 2014-03: by³o tak zrobione, ¿e dzia³a³o - po ka¿dej zmianie pozycji by³a wywo³ywana ta
|
||
funkcja
|
||
// if (BrakeSystem==Pneumatic?BrakeSubsystem==Oerlikon:false) //tylko Oerlikon akceptuje u³amki
|
||
if(false)
|
||
if (fBrakeCtrlPos>0.0)
|
||
{//wartoœci poœrednie wyliczamy tylko dla hamowania
|
||
double u=fBrakeCtrlPos-double(x); //u³amek ponad wartoœæ ca³kowit¹
|
||
if (u>0.0)
|
||
{//wyliczamy wartoœci wa¿one
|
||
BrakePressureActual.PipePressureVal+=-u*BrakePressureActual.PipePressureVal+u*BrakePressureTable[BrakeCtrlPos+1+2].PipePressureVal;
|
||
//BrakePressureActual.BrakePressureVal+=-u*BrakePressureActual.BrakePressureVal+u*BrakePressureTable[BrakeCtrlPos+1].BrakePressureVal;
|
||
//to chyba nie bêdzie tak dzia³aæ, zw³aszcza w EN57
|
||
BrakePressureActual.FlowSpeedVal+=-u*BrakePressureActual.FlowSpeedVal+u*BrakePressureTable[BrakeCtrlPos+1+2].FlowSpeedVal;
|
||
}
|
||
}
|
||
*/
|
||
};
|
||
|
||
bool TMoverParameters::BrakeLevelAdd(double b)
|
||
{ // dodanie wartoœci (b) do pozycji hamulca (w tym ujemnej)
|
||
// zwraca false, gdy po dodaniu by³o by poza zakresem
|
||
BrakeLevelSet(fBrakeCtrlPos + b);
|
||
return b > 0.0 ? (fBrakeCtrlPos < BrakeCtrlPosNo) :
|
||
(BrakeCtrlPos > -1.0); // true, jeœli mo¿na kontynuowaæ
|
||
};
|
||
|
||
bool TMoverParameters::IncBrakeLevel()
|
||
{ // nowa wersja na u¿ytek AI, false gdy osi¹gniêto pozycjê BrakeCtrlPosNo
|
||
return BrakeLevelAdd(1.0);
|
||
};
|
||
|
||
bool TMoverParameters::DecBrakeLevel()
|
||
{ // nowa wersja na u¿ytek AI, false gdy osi¹gniêto pozycjê -1
|
||
return BrakeLevelAdd(-1.0);
|
||
};
|
||
|
||
bool TMoverParameters::ChangeCab(int direction)
|
||
{ // zmiana kabiny i resetowanie ustawien
|
||
if (abs(ActiveCab + direction) < 2)
|
||
{
|
||
// if (ActiveCab+direction=0) then LastCab:=ActiveCab;
|
||
ActiveCab = ActiveCab + direction;
|
||
if ((BrakeSystem == Pneumatic) && (BrakeCtrlPosNo > 0))
|
||
{
|
||
// if (BrakeHandle==FV4a) //!!!POBIERAÆ WARTOŒÆ Z KLASY ZAWORU!!!
|
||
// BrakeLevelSet(-2); //BrakeCtrlPos=-2;
|
||
// else if ((BrakeHandle==FVel6)||(BrakeHandle==St113))
|
||
// BrakeLevelSet(2);
|
||
// else
|
||
// BrakeLevelSet(1);
|
||
BrakeLevelSet(Handle->GetPos(bh_NP));
|
||
LimPipePress = PipePress;
|
||
ActFlowSpeed = 0;
|
||
}
|
||
else
|
||
// if (TrainType=dt_EZT) and (BrakeCtrlPosNo>0) then
|
||
// BrakeCtrlPos:=5; //z Megapacka
|
||
// else
|
||
// BrakeLevelSet(0); //BrakeCtrlPos=0;
|
||
BrakeLevelSet(Handle->GetPos(bh_NP));
|
||
// if not TestFlag(BrakeStatus,b_dmg) then
|
||
// BrakeStatus:=b_off; //z Megapacka
|
||
MainCtrlPos = 0;
|
||
ScndCtrlPos = 0;
|
||
// Ra: to poni¿ej jest bez sensu - mo¿na przejœæ nie wy³¹czaj¹c
|
||
// if ((EngineType!=DieselEngine)&&(EngineType!=DieselElectric))
|
||
//{
|
||
// Mains=false;
|
||
// CompressorAllow=false;
|
||
// ConverterAllow=false;
|
||
//}
|
||
// ActiveDir=0;
|
||
// DirAbsolute=0;
|
||
return true;
|
||
}
|
||
return false;
|
||
};
|
||
|
||
bool TMoverParameters::CurrentSwitch(int direction)
|
||
{ // rozruch wysoki (true) albo niski (false)
|
||
// Ra: przenios³em z Train.cpp, nie wiem czy ma to sens
|
||
if (MaxCurrentSwitch(direction))
|
||
{
|
||
if (TrainType != dt_EZT)
|
||
return (MinCurrentSwitch(direction));
|
||
}
|
||
if (EngineType == DieselEngine) // dla 2Ls150
|
||
if (ShuntModeAllow)
|
||
if (ActiveDir == 0) // przed ustawieniem kierunku
|
||
ShuntMode = direction;
|
||
return false;
|
||
};
|
||
|
||
void TMoverParameters::UpdatePantVolume(double dt)
|
||
{ // KURS90 - sprê¿arka pantografów; Ra 2014-07: teraz jest to zbiornik rozrz¹du, chocia¿ to jeszcze
|
||
// nie tak
|
||
if (EnginePowerSource.SourceType == CurrentCollector) // tylko jeœli pantografuj¹cy
|
||
{
|
||
// Ra 2014-07: zasadniczo, to istnieje zbiornik rozrz¹du i zbiornik pantografów - na razie
|
||
// mamy razem
|
||
// Ra 2014-07: kurek trójdrogowy ³¹czy spr.pom. z pantografami i wy³¹cznikiem ciœnieniowym
|
||
// WS
|
||
// Ra 2014-07: zbiornika rozrz¹du nie pompuje siê tu, tylko pantografy; potem mo¿na zamkn¹æ
|
||
// WS i odpaliæ resztê
|
||
if ((TrainType == dt_EZT) ? (PantPress < ScndPipePress) :
|
||
bPantKurek3) // kurek zamyka po³¹czenie z ZG
|
||
{ // zbiornik pantografu po³¹czony ze zbiornikiem g³ównym - ma³¹ sprê¿ark¹ siê tego nie
|
||
// napompuje
|
||
// Ra 2013-12: Niebugoc³aw mówi, ¿e w EZT nie ma potrzeby odcinaæ kurkiem
|
||
PantPress = EnginePowerSource.CollectorParameters
|
||
.MaxPress; // ograniczenie ciœnienia do MaxPress (tylko w pantografach!)
|
||
if (PantPress > ScndPipePress)
|
||
PantPress = ScndPipePress; // oraz do ScndPipePress
|
||
PantVolume = (PantPress + 1) * 0.1; // objêtoœæ, na wypadek odciêcia kurkiem
|
||
}
|
||
else
|
||
{ // zbiornik g³ówny odciêty, mo¿na pompowaæ pantografy
|
||
if (PantCompFlag && Battery) // w³¹czona bateria i ma³a sprê¿arka
|
||
PantVolume += dt * (TrainType == dt_EZT ? 0.003 : 0.005) *
|
||
(2 * 0.45 - ((0.1 / PantVolume / 10) - 0.1)) /
|
||
0.45; // nape³nianie zbiornika pantografów
|
||
// Ra 2013-12: Niebugoc³aw mówi, ¿e w EZT nabija 1.5 raz wolniej ni¿ jak by³o 0.005
|
||
PantPress = (10.0 * PantVolume) - 1.0; // tu by siê przyda³a objêtoœæ zbiornika
|
||
}
|
||
if (!PantCompFlag && (PantVolume > 0.1))
|
||
PantVolume -= dt * 0.0003; // nieszczelnoœci: 0.0003=0.3l/s
|
||
if (Mains) // nie wchodziæ w funkcjê bez potrzeby
|
||
if (EngineType == ElectricSeriesMotor) // nie dotyczy... czego w³aœciwie?
|
||
if (PantPress < EnginePowerSource.CollectorParameters.MinPress)
|
||
if ((TrainType & (dt_EZT | dt_ET40 | dt_ET41 | dt_ET42)) ?
|
||
(GetTrainsetVoltage() < EnginePowerSource.CollectorParameters.MinV) :
|
||
true) // to jest trochê proteza; zasilanie cz³onu mo¿e byæ przez sprzêg
|
||
// WN
|
||
if (MainSwitch(false))
|
||
EventFlag = true; // wywalenie szybkiego z powodu niskiego ciœnienia
|
||
if (TrainType != dt_EZT) // w EN57 pompuje siê tylko w silnikowym
|
||
// pierwotnie w CHK pantografy mia³y równie¿ rozrz¹dcze EZT
|
||
for (int b = 0; b <= 1; ++b)
|
||
if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll))
|
||
if (Couplers[b].Connected->PantVolume <
|
||
PantVolume) // bo inaczej trzeba w obydwu cz³onach przestawiaæ
|
||
Couplers[b].Connected->PantVolume =
|
||
PantVolume; // przekazanie ciœnienia do s¹siedniego cz³onu
|
||
// czy np. w ET40, ET41, ET42 pantografy cz³onów maj¹ po³¹czenie pneumatyczne?
|
||
// Ra 2014-07: raczej nie - najpierw siê za³¹cza jeden cz³on, a potem mo¿na podnieœæ w
|
||
// drugim
|
||
}
|
||
else
|
||
{ // a tu coœ dla SM42 i SM31, aby pokazywaæ na manometrze
|
||
PantPress = CntrlPipePress;
|
||
}
|
||
};
|
||
|
||
void TMoverParameters::UpdateBatteryVoltage(double dt)
|
||
{ // przeliczenie obci¹¿enia baterii
|
||
double sn1, sn2, sn3, sn4, sn5; // Ra: zrobiæ z tego amperomierz NN
|
||
if ((BatteryVoltage > 0) && (EngineType != DieselEngine) && (EngineType != WheelsDriven) &&
|
||
(NominalBatteryVoltage > 0))
|
||
{
|
||
if ((NominalBatteryVoltage / BatteryVoltage < 1.22) && Battery)
|
||
{ // 110V
|
||
if (!ConverterFlag)
|
||
sn1 = (dt * 2.0); // szybki spadek do ok 90V
|
||
else
|
||
sn1 = 0;
|
||
if (ConverterFlag)
|
||
sn2 = -(dt * 2.0); // szybki wzrost do 110V
|
||
else
|
||
sn2 = 0;
|
||
if (Mains)
|
||
sn3 = (dt * 0.05);
|
||
else
|
||
sn3 = 0;
|
||
if (iLights[0] & 63) // 64=blachy, nie ci¹gn¹ pr¹du //rozpisaæ na poszczególne
|
||
// ¿arówki...
|
||
sn4 = dt * 0.003;
|
||
else
|
||
sn4 = 0;
|
||
if (iLights[1] & 63) // 64=blachy, nie ci¹gn¹ pr¹du
|
||
sn5 = dt * 0.001;
|
||
else
|
||
sn5 = 0;
|
||
};
|
||
if ((NominalBatteryVoltage / BatteryVoltage >= 1.22) && Battery)
|
||
{ // 90V
|
||
if (PantCompFlag)
|
||
sn1 = (dt * 0.0046);
|
||
else
|
||
sn1 = 0;
|
||
if (ConverterFlag)
|
||
sn2 = -(dt * 50); // szybki wzrost do 110V
|
||
else
|
||
sn2 = 0;
|
||
if (Mains)
|
||
sn3 = (dt * 0.001);
|
||
else
|
||
sn3 = 0;
|
||
if (iLights[0] & 63) // 64=blachy, nie ci¹gn¹ pr¹du
|
||
sn4 = (dt * 0.0030);
|
||
else
|
||
sn4 = 0;
|
||
if (iLights[1] & 63) // 64=blachy, nie ci¹gn¹ pr¹du
|
||
sn5 = (dt * 0.0010);
|
||
else
|
||
sn5 = 0;
|
||
};
|
||
if (!Battery)
|
||
{
|
||
if (NominalBatteryVoltage / BatteryVoltage < 1.22)
|
||
sn1 = dt * 50;
|
||
else
|
||
sn1 = 0;
|
||
sn2 = dt * 0.000001;
|
||
sn3 = dt * 0.000001;
|
||
sn4 = dt * 0.000001;
|
||
sn5 = dt * 0.000001; // bardzo powolny spadek przy wy³¹czonych bateriach
|
||
};
|
||
BatteryVoltage -= (sn1 + sn2 + sn3 + sn4 + sn5);
|
||
if (NominalBatteryVoltage / BatteryVoltage > 1.57)
|
||
if (MainSwitch(false) && (EngineType != DieselEngine) && (EngineType != WheelsDriven))
|
||
EventFlag = true; // wywalanie szybkiego z powodu zbyt niskiego napiecia
|
||
if (BatteryVoltage > NominalBatteryVoltage)
|
||
BatteryVoltage = NominalBatteryVoltage; // wstrzymanie ³adowania pow. 110V
|
||
if (BatteryVoltage < 0.01)
|
||
BatteryVoltage = 0.01;
|
||
}
|
||
else if (NominalBatteryVoltage == 0)
|
||
BatteryVoltage = 0;
|
||
else
|
||
BatteryVoltage = 90;
|
||
};
|
||
|
||
/* Ukrotnienie EN57:
|
||
1 //uk³ad szeregowy
|
||
2 //uk³ad równoleg³y
|
||
3 //bocznik 1
|
||
4 //bocznik 2
|
||
5 //bocznik 3
|
||
6 //do przodu
|
||
7 //do ty³u
|
||
8 //1 przyspieszenie
|
||
9 //minus obw. 2 przyspieszenia
|
||
10 //jazda na oporach
|
||
11 //SHP
|
||
12A //podnoszenie pantografu przedniego
|
||
12B //podnoszenie pantografu tylnego
|
||
13A //opuszczanie pantografu przedniego
|
||
13B //opuszczanie wszystkich pantografów
|
||
14 //za³¹czenie WS
|
||
15 //rozrz¹d (WS, PSR, wa³ ku³akowy)
|
||
16 //odblok PN
|
||
18 //sygnalizacja przetwornicy g³ównej
|
||
19 //luzowanie EP
|
||
20 //hamowanie EP
|
||
21 //rezerwa** (1900+: zamykanie drzwi prawych)
|
||
22 //za³. przetwornicy g³ównej
|
||
23 //wy³. przetwornicy g³ównej
|
||
24 //za³. przetw. oœwietlenia
|
||
25 //wy³. przetwornicy oœwietlenia
|
||
26 //sygnalizacja WS
|
||
28 //sprê¿arka
|
||
29 //ogrzewanie
|
||
30 //rezerwa* (1900+: zamykanie drzwi lewych)
|
||
31 //otwieranie drzwi prawych
|
||
32H //zadzia³anie PN siln. trakcyjnych
|
||
33 //sygna³ odjazdu
|
||
34 //rezerwa (sygnalizacja poœlizgu)
|
||
35 //otwieranie drzwi lewych
|
||
ZN //masa
|
||
*/
|
||
|
||
double TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShape &Shape,
|
||
TTrackParam &Track, TTractionParam &ElectricTraction,
|
||
const TLocation &NewLoc, TRotation &NewRot)
|
||
{ // trzeba po ma³u przenosiæ tu tê funkcjê
|
||
double d;
|
||
T_MoverParameters::ComputeMovement(dt, dt1, Shape, Track, ElectricTraction, NewLoc, NewRot);
|
||
if (Power > 1.0) // w rozrz¹dczym nie (jest b³¹d w FIZ!) - Ra 2014-07: teraz we wszystkich
|
||
UpdatePantVolume(dt); // Ra 2014-07: obs³uga zbiornika rozrz¹du oraz pantografów
|
||
|
||
if (EngineType == WheelsDriven)
|
||
d = CabNo * dL; // na chwile dla testu
|
||
else
|
||
d = dL;
|
||
DistCounter = DistCounter + fabs(dL) / 1000.0;
|
||
dL = 0;
|
||
|
||
// koniec procedury, tu nastepuja dodatkowe procedury pomocnicze
|
||
|
||
// sprawdzanie i ewentualnie wykonywanie->kasowanie poleceñ
|
||
if (LoadStatus > 0) // czas doliczamy tylko jeœli trwa (roz)³adowanie
|
||
LastLoadChangeTime = LastLoadChangeTime + dt; // czas (roz)³adunku
|
||
RunInternalCommand();
|
||
// automatyczny rozruch
|
||
if (EngineType == ElectricSeriesMotor)
|
||
if (AutoRelayCheck())
|
||
SetFlag(SoundFlag, sound_relay);
|
||
/*
|
||
else {McZapkie-041003: aby slychac bylo przelaczniki w sterowniczym}
|
||
if (EngineType=None) and (MainCtrlPosNo>0) then
|
||
for b:=0 to 1 do
|
||
with Couplers[b] do
|
||
if TestFlag(CouplingFlag,ctrain_controll) then
|
||
if Connected^.Power>0.01 then
|
||
SoundFlag:=SoundFlag or Connected^.SoundFlag;
|
||
*/
|
||
if (EngineType == DieselEngine)
|
||
if (dizel_Update(dt))
|
||
SetFlag(SoundFlag, sound_relay);
|
||
// uklady hamulcowe:
|
||
if (VeselVolume > 0)
|
||
Compressor = CompressedVolume / VeselVolume;
|
||
else
|
||
{
|
||
Compressor = 0;
|
||
CompressorFlag = false;
|
||
};
|
||
ConverterCheck();
|
||
if (CompressorSpeed > 0.0) // sprê¿arka musi mieæ jak¹œ niezerow¹ wydajnoœæ
|
||
CompressorCheck(dt); //¿eby rozwa¿aæ jej za³¹czenie i pracê
|
||
UpdateBrakePressure(dt);
|
||
UpdatePipePressure(dt);
|
||
UpdateBatteryVoltage(dt);
|
||
UpdateScndPipePressure(dt); // druga rurka, youBy
|
||
// hamulec antypoœlizgowy - wy³¹czanie
|
||
if ((BrakeSlippingTimer > 0.8) && (ASBType != 128)) // ASBSpeed=0.8
|
||
Hamulec->ASB(0);
|
||
// SetFlag(BrakeStatus,-b_antislip);
|
||
BrakeSlippingTimer = BrakeSlippingTimer + dt;
|
||
// sypanie piasku - wy³¹czone i piasek siê nie koñczy - b³êdy AI
|
||
// if AIControllFlag then
|
||
// if SandDose then
|
||
// if Sand>0 then
|
||
// begin
|
||
// Sand:=Sand-NPoweredAxles*SandSpeed*dt;
|
||
// if Random<dt then SandDose:=false;
|
||
// end
|
||
// else
|
||
// begin
|
||
// SandDose:=false;
|
||
// Sand:=0;
|
||
// end;
|
||
// czuwak/SHP
|
||
// if (Vel>10) and (not DebugmodeFlag) then
|
||
if (!DebugModeFlag)
|
||
SecuritySystemCheck(dt1);
|
||
return d;
|
||
};
|
||
|
||
double TMoverParameters::FastComputeMovement(double dt, const TTrackShape &Shape,
|
||
TTrackParam &Track, const TLocation &NewLoc,
|
||
TRotation &NewRot)
|
||
{ // trzeba po ma³u przenosiæ tu tê funkcjê
|
||
double d;
|
||
T_MoverParameters::FastComputeMovement(dt, Shape, Track, NewLoc, NewRot);
|
||
if (Power > 1.0) // w rozrz¹dczym nie (jest b³¹d w FIZ!)
|
||
UpdatePantVolume(dt); // Ra 2014-07: obs³uga zbiornika rozrz¹du oraz pantografów
|
||
if (EngineType == WheelsDriven)
|
||
d = CabNo * dL; // na chwile dla testu
|
||
else
|
||
d = dL;
|
||
DistCounter = DistCounter + fabs(dL) / 1000.0;
|
||
dL = 0;
|
||
|
||
// koniec procedury, tu nastepuja dodatkowe procedury pomocnicze
|
||
|
||
// sprawdzanie i ewentualnie wykonywanie->kasowanie poleceñ
|
||
if (LoadStatus > 0) // czas doliczamy tylko jeœli trwa (roz)³adowanie
|
||
LastLoadChangeTime = LastLoadChangeTime + dt; // czas (roz)³adunku
|
||
RunInternalCommand();
|
||
if (EngineType == DieselEngine)
|
||
if (dizel_Update(dt))
|
||
SetFlag(SoundFlag, sound_relay);
|
||
// uklady hamulcowe:
|
||
if (VeselVolume > 0)
|
||
Compressor = CompressedVolume / VeselVolume;
|
||
else
|
||
{
|
||
Compressor = 0;
|
||
CompressorFlag = false;
|
||
};
|
||
ConverterCheck();
|
||
if (CompressorSpeed > 0.0) // sprê¿arka musi mieæ jak¹œ niezerow¹ wydajnoœæ
|
||
CompressorCheck(dt); //¿eby rozwa¿aæ jej za³¹czenie i pracê
|
||
UpdateBrakePressure(dt);
|
||
UpdatePipePressure(dt);
|
||
UpdateScndPipePressure(dt); // druga rurka, youBy
|
||
UpdateBatteryVoltage(dt);
|
||
// hamulec antyposlizgowy - wy³¹czanie
|
||
if ((BrakeSlippingTimer > 0.8) && (ASBType != 128)) // ASBSpeed=0.8
|
||
Hamulec->ASB(0);
|
||
BrakeSlippingTimer = BrakeSlippingTimer + dt;
|
||
return d;
|
||
};
|
||
|
||
double TMoverParameters::ShowEngineRotation(int VehN)
|
||
{ // pokazywanie obrotów silnika, równie¿ dwóch dalszych pojazdów (3×SN61)
|
||
int b;
|
||
switch (VehN)
|
||
{ // numer obrotomierza
|
||
case 1:
|
||
return fabs(enrot);
|
||
case 2:
|
||
for (b = 0; b <= 1; ++b)
|
||
if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll))
|
||
if (Couplers[b].Connected->Power > 0.01)
|
||
return fabs(Couplers[b].Connected->enrot);
|
||
break;
|
||
case 3: // to nie uwzglêdnia ewentualnego odwrócenia pojazdu w œrodku
|
||
for (b = 0; b <= 1; ++b)
|
||
if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll))
|
||
if (Couplers[b].Connected->Power > 0.01)
|
||
if (TestFlag(Couplers[b].Connected->Couplers[b].CouplingFlag, ctrain_controll))
|
||
if (Couplers[b].Connected->Couplers[b].Connected->Power > 0.01)
|
||
return fabs(Couplers[b].Connected->Couplers[b].Connected->enrot);
|
||
break;
|
||
};
|
||
return 0.0;
|
||
};
|
||
|
||
void TMoverParameters::ConverterCheck()
|
||
{ // sprawdzanie przetwornicy
|
||
if (ConverterAllow && Mains && !ConvOvldFlag)
|
||
ConverterFlag = true;
|
||
else
|
||
ConverterFlag = false;
|
||
};
|
||
|
||
int TMoverParameters::ShowCurrent(Byte AmpN)
|
||
{ // odczyt ampera¿u
|
||
switch (EngineType)
|
||
{
|
||
case ElectricInductionMotor:
|
||
switch (AmpN)
|
||
{ // do asynchronicznych
|
||
case 1:
|
||
return WindingRes * Mm / Vadd;
|
||
case 2:
|
||
return dizel_fill * WindingRes;
|
||
default:
|
||
return T_MoverParameters::ShowCurrent(AmpN);
|
||
}
|
||
break;
|
||
case DieselElectric:
|
||
return fabs(Im);
|
||
break;
|
||
default:
|
||
return T_MoverParameters::ShowCurrent(AmpN);
|
||
}
|
||
};
|