18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-19 22:44:59 +01:00
Files
maszyna/tests/unit/drive.cpp
jerrrrycho 5a20f86fd0 feat: line breaker before the pantographs, Cntrl.PantRequiresMain (#68)
New optional .fiz key Cntrl.PantRequiresMain (default No, every existing
vehicle unchanged). With Yes, as on Czech-built locomotives:
- the line breaker closes on the low voltage circuits, without traction
  voltage, and the undervoltage trip doesn't open it (overvoltage and the
  other trips still do);
- a pantograph valve opens and stays open only while the vehicle's line
  breaker is closed, so opening it drops the pantographs.

The AI (TController::PrepareEngine) closes the line breaker before raising
the pantographs for such a vehicle; the line breaker steps moved into
TController::close_line_breaker(). test::start_up() follows the same order.

Game data: to use it, PantRequiresMain=Yes goes on the Cntrl. line of
dynamic/pkp/ep05_v2/ep05.fiz, ep05v1.fiz and dynamic/cd/181_v2/181_cz1.fiz,
18x_pl.fiz (left for later, not part of this change). (#68)
2026-11-07 19:18:37 +01:00

254 lines
8.7 KiB
C++

#include "stdafx.h"
#include "drive.h"
#include "consist.h"
#include "golden.h"
#include "doctest.h"
#include "McZapkie/hamulce.h"
namespace test {
void mark(trace *Trace, std::string const &Event) {
if (Trace != nullptr) {
Trace->mark(Event);
}
}
bool is_powered(TMoverParameters const &Vehicle) {
using enum TEngineType;
auto const type{Vehicle.EngineType};
return Vehicle.Power > 1.0 && (type == ElectricSeriesMotor || type == ElectricInductionMotor || type == DieselEngine || type == DieselElectric);
}
driven driving(vehicle &Vehicle) {
return {Vehicle.mover(), Vehicle.mover(), Vehicle.mover(), [&Vehicle](double Seconds, track const &Track) { Vehicle.run(Seconds, Track); }};
}
driven driving(consist &Consist) {
// the AI's mvControlling and mvPantographUnit: the first vehicle with an engine, and with pantographs
auto *controlling{&Consist[0].mover()};
auto *pantographs{&Consist[0].mover()};
for (auto i = Consist.size(); i-- > 0;) {
auto &mover{Consist[i].mover()};
if (is_powered(mover)) {
controlling = &mover;
}
if (mover.EnginePowerSource.SourceType == TPowerSource::CurrentCollector && mover.EnginePowerSource.CollectorParameters.CollectorsNo > 0) {
pantographs = &mover;
}
}
return {Consist[0].mover(), *controlling, *pantographs, [&Consist](double Seconds, track const &Track) { Consist.run(Seconds, Track); }};
}
namespace {
void attend(TMoverParameters &Mover) {
if (Mover.SecuritySystem.is_cabsignal_blinking() && Mover.SecuritySystem.has_separate_acknowledge()) {
Mover.SecuritySystem.cabsignal_reset();
}
if (Mover.SecuritySystem.is_blinking()) {
Mover.SecuritySystemReset();
}
}
} // namespace
void drive(driven Driven, track const &Track, double Seconds) {
auto const seconds{std::lround(Seconds)};
for (long second = 0; second < seconds; ++second) {
attend(Driven.cab);
Driven.run(1.0, Track);
}
}
void release_brakes(TMoverParameters &Cab) {
Cab.BrakeLevelSet(Cab.Handle->GetPos(bh_RP));
Cab.DecLocalBrakeLevel(LocalBrakePosNo);
Cab.DecManualBrakeLevel(ManualBrakePosNo);
Cab.SpringBrakeActivate(false);
// the hand and spring brakes of the rest of the train, as TController::AutoRewident() releases them
std::vector train{&Cab};
std::vector pending{&Cab};
while (false == pending.empty()) {
auto const *vehicle{pending.back()};
pending.pop_back();
for (auto const &thiscoupler : vehicle->Couplers) {
if (thiscoupler.Connected != nullptr && thiscoupler.CouplingFlag != coupling::faux && std::ranges::find(train, thiscoupler.Connected) == train.end()) {
thiscoupler.Connected->DecManualBrakeLevel(ManualBrakePosNo);
thiscoupler.Connected->SpringBrake.Activate = false;
train.push_back(thiscoupler.Connected);
pending.push_back(thiscoupler.Connected);
}
}
}
}
bool is_ready(driven const &Driven) {
auto const &mover{Driven.controlling};
auto const air{mover.VeselVolume <= 0.0 || mover.ScndPipePress >= 4.5};
// the converter feeds the 110 V circuits (the electrodynamic brake's control among them); the AI switches
// it on once the line breaker is closed, so a train already charged with air isn't ready before it runs
auto const converter{mover.ConverterStart != start_t::manual || mover.ConverterFlag};
return mover.Mains && air && converter;
}
namespace {
// the pumps and the heater of a diesel's water, and the fuel pump
void prepare_diesel(driven const &Driven) {
Driven.cab.OilPumpSwitch(true);
Driven.controlling.WaterPumpBreakerSwitch(true);
Driven.controlling.WaterPumpSwitch(true);
Driven.controlling.WaterHeaterBreakerSwitch(true);
Driven.controlling.WaterHeaterSwitch(true);
Driven.cab.FuelPumpSwitch(true);
}
// the pantographs' own air topped up by their compressor, and the pantographs raised
void raise_pantographs(driven const &Driven) {
auto &pantographs{Driven.pantographs};
if (auto const enough{(pantographs.TrainType == dt_EZT ? 2.5 : 3.5) + 0.1}; pantographs.PantPress < enough) {
if (false == pantographs.PantAutoValve) {
pantographs.bPantKurek3 = false; // the pantographs on their own air
}
pantographs.PantCompFlag = true;
}
else if (false == pantographs.bPantKurek3 || pantographs.PantPress <= pantographs.ScndPipePress) {
pantographs.PantCompFlag = false;
}
Driven.cab.OperatePantographsValve(operation_t::enable);
Driven.cab.OperatePantographValve(end::rear, operation_t::enable);
}
// the line breaker closed, which it does only with the controller at zero, and after the relays are reset
void close_line_breaker(driven const &Driven) {
auto &controlling{Driven.controlling};
while (controlling.DecMainCtrl(2)) {
// down to zero
}
controlling.DecScndCtrl(2);
Driven.cab.RelayReset(relay_t::maincircuitground | relay_t::tractionnmotoroverload | relay_t::primaryconverteroverload);
if (controlling.EngineType == TEngineType::DieselEngine) {
// a mechanical diesel starts at idle, the first position giving the engine fuel
while (controlling.RList[controlling.MainCtrlPos].Mn == 0 && controlling.IncMainCtrl(1)) {
// up to the first position with fuel
}
}
Driven.cab.MainSwitch(true);
}
// the converter, the compressor and the motor blowers, once the line breaker is closed
void switch_auxiliaries_on(TMoverParameters &Cab) {
Cab.ConverterSwitch(true);
Cab.CompressorSwitch(true);
for (auto const side : {end::front, end::rear}) {
if (Cab.MotorBlowers[side].speed != 0) {
Cab.MotorBlowersSwitchOff(false, side);
Cab.MotorBlowersSwitch(true, side);
}
}
}
} // namespace
bool start_up(driven Driven, track const &Track, double Seconds, trace *Trace) {
auto &cab{Driven.cab};
auto const &controlling{Driven.controlling};
auto const &pantographs{Driven.pantographs};
mark(Trace, "start up");
auto const diesel{controlling.EngineType == TEngineType::DieselEngine || controlling.EngineType == TEngineType::DieselElectric};
auto const collector{pantographs.EnginePowerSource.SourceType == TPowerSource::CurrentCollector &&
pantographs.EnginePowerSource.CollectorParameters.CollectorsNo > 0};
// the converter and the compressor get switched on once the line breaker is closed, wherever in the train
// they are; a train already charged with air isn't ready before that
auto auxiliaries{false};
// one round of the driver's actions a second, as the AI reacts
for (auto second = 0; second < Seconds; ++second) {
cab.BatterySwitch(true);
cab.CabActivisation();
if (diesel) {
prepare_diesel(Driven);
}
if (controlling.PantographsRequireMains && false == controlling.Mains) {
// the pantographs rise only through the closed line breaker, which closes without their voltage
for (int i = 0; i < 3 && cab.DirActive <= 0; ++i) {
cab.DirectionForward();
}
close_line_breaker(Driven);
}
if (collector) {
raise_pantographs(Driven);
}
if (false == collector || std::max(controlling.GetTrainsetHighVoltage(), controlling.PantographVoltage) > controlling.EnginePowerSource.CollectorParameters.MinV) {
// a direction first, as in TController::PrepareDirection(): the relays reset only with one set
for (int i = 0; i < 3 && cab.DirActive <= 0; ++i) {
cab.DirectionForward();
}
if (false == controlling.Mains) {
close_line_breaker(Driven);
}
else {
switch_auxiliaries_on(cab);
auxiliaries = true;
}
}
drive(Driven, Track, 1.0);
if (auxiliaries && is_ready(Driven)) {
mark(Trace, "ready");
return true;
}
}
return false;
}
void drive_cycle(driven Driven, track const &Track, trace &Trace) {
auto &cab{Driven.cab};
auto &controlling{Driven.controlling};
if (false == start_up(Driven, Track, 300.0, &Trace)) {
MESSAGE("didn't get ready: Mains " << controlling.Mains << ", main reservoir " << controlling.ScndPipePress);
}
Trace.mark("release brakes");
release_brakes(cab);
drive(Driven, Track, 30.0);
Trace.mark("forward");
for (int i = 0; i < 3 && cab.DirActive <= 0; ++i) {
cab.DirectionForward();
}
drive(Driven, Track, 2.0);
Trace.mark("notch up");
for (int i = 0; i < 60 && false == controlling.IsMainCtrlMaxPowerPos(); ++i) {
controlling.IncMainCtrl(1);
drive(Driven, Track, 2.0);
}
Trace.mark("full power");
drive(Driven, Track, 30.0);
Trace.mark("second controller up");
for (int i = 0; i < 20 && controlling.IncScndCtrl(1); ++i) {
drive(Driven, Track, 2.0);
}
drive(Driven, Track, 20.0);
Trace.mark("second controller down");
for (int i = 0; i < 20 && controlling.DecScndCtrl(1); ++i) {
drive(Driven, Track, 1.0);
}
Trace.mark("notch down");
for (int i = 0; i < 60 && controlling.DecMainCtrl(1); ++i) {
drive(Driven, Track, 1.0);
}
Trace.mark("coast");
drive(Driven, Track, 10.0);
Trace.mark("brake");
cab.BrakeLevelSet(cab.Handle->GetPos(bh_FB));
drive(Driven, Track, 60.0);
Trace.mark("release");
cab.BrakeLevelSet(cab.Handle->GetPos(bh_RP));
drive(Driven, Track, 20.0);
}
} // namespace test