diff --git a/McZapkie/MOVER.h b/McZapkie/MOVER.h index 8b440f2b1..08c561c0c 100644 --- a/McZapkie/MOVER.h +++ b/McZapkie/MOVER.h @@ -1987,6 +1987,7 @@ class TMoverParameters double MirrorVelClose{5.0}; bool MirrorForbidden{false}; /*czy jest pozwolenie na otworzenie lusterek (przycisk)*/ bool ScndS = false; /*Czy jest bocznikowanie na szeregowej*/ + bool ScndCtrlResistiveLock{false}; // the shunt controller can't be moved, up or down, while the master controller is at zero or on a resistive position, and drops to 0 when the master controller gets there (ScndCtrlResistiveLock=Yes in Cntrl.) bool SpeedCtrl = false; /*czy jest tempomat*/ speed_control SpeedCtrlUnit; /*parametry tempomatu*/ double SpeedCtrlButtons[10]{30, 40, 50, 60, 70, 80, 90, 100, 110, 120}; /*przyciski prędkości*/ @@ -2430,6 +2431,11 @@ class TMoverParameters bool IncScndCtrl(int CtrlSpeed); bool DecScndCtrl(int CtrlSpeed); int GetVirtualScndPos() const; + // whether ScndCtrlResistiveLock keeps the shunt controller from being moved at the current master controller position + bool IsScndCtrlLockedByMainCtrl() const; + // ScndCtrlResistiveLock: the shunt controller drops to 0 once the master controller is at zero or on a resistive position, so it + // can't stay engaged there, locked in place (eu07/maszyna#402) + void ScndCtrlResistiveLockCheck(); bool IsScndCtrlNoPowerPos() const; bool IsScndCtrlMaxPowerPos() const; diff --git a/McZapkie/Mover.cpp b/McZapkie/Mover.cpp index b94a1e943..ecc216a71 100644 --- a/McZapkie/Mover.cpp +++ b/McZapkie/Mover.cpp @@ -1698,6 +1698,8 @@ void TMoverParameters::compute_movement_(double const Deltatime) BRVentilators = false; } + // the master controller set directly, not through IncMainCtrl()/DecMainCtrl() (AI, consist): the locked shunt follows it as well + ScndCtrlResistiveLockCheck(); // automatyczny rozruch if (EngineType == TEngineType::ElectricSeriesMotor && AutoRelayCheck()) { @@ -2604,6 +2606,7 @@ bool TMoverParameters::IncMainCtrl(int CtrlSpeed) if (true == OK) { + ScndCtrlResistiveLockCheck(); // e.g. from the last series position on to the resistive parallel ones SendCtrlToNext("MainCtrl", MainCtrlPos, CabActive); //??? SendCtrlToNext("ScndCtrl", ScndCtrlPos, CabActive); } @@ -2729,6 +2732,7 @@ bool TMoverParameters::DecMainCtrl(int CtrlSpeed) if (OK) { + ScndCtrlResistiveLockCheck(); // the shunt drops when the master controller leaves a resistance-free position /*OK:=*/SendCtrlToNext("MainCtrl", MainCtrlPos, CabActive); // hmmmm...???!!! /*OK:=*/SendCtrlToNext("ScndCtrl", ScndCtrlPos, CabActive); } @@ -2818,7 +2822,7 @@ bool TMoverParameters::IncScndCtrl(int CtrlSpeed) { // if (RList[MainCtrlPos].R=0) and (MainCtrlPos>0) and (ScndCtrlPos 0 && CabActive != 0) { - if (ScndCtrlPos > 0 && !CoupledCtrl && (EngineType != TEngineType::DieselElectric || !AutoRelayFlag)) + if (ScndCtrlPos > 0 && !CoupledCtrl && (EngineType != TEngineType::DieselElectric || !AutoRelayFlag) && !IsScndCtrlLockedByMainCtrl()) { if (CtrlSpeed == 1) { @@ -2939,6 +2943,22 @@ bool TMoverParameters::DecScndCtrl(int CtrlSpeed) return OK; } +bool TMoverParameters::IsScndCtrlLockedByMainCtrl() const +{ + // ET21, ET22, EP09: the field shunting engages only on the resistance-free positions of the master controller (eu07/maszyna#402) + return ScndCtrlResistiveLock && (IsMainCtrlNoPowerPos() || RList[MainCtrlPos].R >= 0.01); +} + +void TMoverParameters::ScndCtrlResistiveLockCheck() +{ + // the shunt controller, locked in both directions on zero and the resistive positions, would otherwise stay engaged there once the + // master controller is taken back (or set from elsewhere, e.g. by the AI or another vehicle of the consist) with the shunt on + if (ScndCtrlPos > 0 && !CoupledCtrl && IsScndCtrlLockedByMainCtrl()) + { + ScndCtrlPos = 0; + } +} + int TMoverParameters::GetVirtualScndPos() const { if (TrainType == dt_ET42 && DynamicBrakeFlag && !ScndCtrlPos) @@ -11105,6 +11125,7 @@ void TMoverParameters::LoadFIZ_Cntrl(std::string const &line) extract_value(EIMCtrlEmergency, "EIMCtrlEmergency", line, ""); extract_value(ScndS, "ScndS", line, ""); // brak pozycji rownoleglej przy niskiej nastawie PSR + extract_value(ScndCtrlResistiveLock, "ScndCtrlResistiveLock", line, ""); // bocznikowanie tylko na pozycjach bezoporowych extract_value(InitialCtrlDelay, "IniCDelay", line, ""); extract_value(CtrlDelay, "SCDelay", line, ""); diff --git a/tests/unit/test_cntrl.cpp b/tests/unit/test_cntrl.cpp index 0dd3ddc20..c73c45d85 100644 --- a/tests/unit/test_cntrl.cpp +++ b/tests/unit/test_cntrl.cpp @@ -37,3 +37,145 @@ TEST_CASE("cntrl: the relays of a multiple unit start on their own, of other veh CHECK(unit->ConverterOverloadRelayStart == start_t::automatic); } } + +namespace { + +// the first position of the master controller after Position without the starting resistors in the circuit +int resistance_free_position(TMoverParameters const &Vehicle, int Position = 0) { + for (auto position{Position + 1}; position <= Vehicle.MainCtrlPosNo; ++position) { + if (Vehicle.RList[position].R < 0.01) { + return position; + } + } + return 0; +} + +// the vehicle with its cab occupied, the master controller set to Position and the shunt controller off +void controllers_at(vehicle &Vehicle, int Position) { + Vehicle->CabActive = 1; + Vehicle->MainCtrlPos = Position; + Vehicle->ScndCtrlPos = 0; +} + +} // namespace + +TEST_CASE("cntrl: ScndCtrlResistiveLock keeps the field shunting off at zero and on the resistive positions (eu07/maszyna#402)") { + for (auto const *path : {"et22_v3/201e-rn", "ep09_v2/104e"}) { + CAPTURE(path); + vehicle locked{definition::fiz(path).set("Cntrl", "ScndCtrlResistiveLock", "Yes"), 0.0, "test", 1}; + REQUIRE(locked->ScndCtrlResistiveLock); + REQUIRE(locked->ScndCtrlPosNo > 0); + auto const resistancefree{resistance_free_position(locked.mover())}; + REQUIRE(resistancefree > 1); + if (resistancefree <= 1) { + continue; // not reached, the REQUIRE above ends the test; tells the static analysis the index below is in range + } + REQUIRE(locked->RList[resistancefree - 1].R >= 0.01); + + SUBCASE("zero") { + controllers_at(locked, 0); + CHECK(locked->IsScndCtrlLockedByMainCtrl()); + CHECK_FALSE(locked->IncScndCtrl(1)); + CHECK_FALSE(locked->IncScndCtrl(2)); + CHECK(locked->ScndCtrlPos == 0); + } + SUBCASE("resistive positions") { + for (auto position{1}; position < resistancefree; ++position) { + CAPTURE(position); + controllers_at(locked, position); + CHECK_FALSE(locked->IncScndCtrl(1)); + CHECK(locked->ScndCtrlPos == 0); + } + } + SUBCASE("every resistance-free position") { + for (auto position{resistancefree}; position > 0; position = resistance_free_position(locked.mover(), position)) { + CAPTURE(position); + controllers_at(locked, position); + CHECK_FALSE(locked->IsScndCtrlLockedByMainCtrl()); + CHECK(locked->IncScndCtrl(1)); + CHECK(locked->ScndCtrlPos == 1); + } + } + SUBCASE("the shunt goes down on a resistance-free position") { + controllers_at(locked, resistancefree); + REQUIRE(locked->IncScndCtrl(1)); + REQUIRE(locked->IncScndCtrl(1)); + CHECK(locked->DecScndCtrl(1)); + CHECK(locked->ScndCtrlPos == 1); + CHECK(locked->DecScndCtrl(2)); + CHECK(locked->ScndCtrlPos == 0); + } + SUBCASE("the shunt doesn't go down on a resistive position either") { + // a state the lock doesn't let arise (see below), set by hand to check the controller alone + controllers_at(locked, resistancefree - 1); + locked->ScndCtrlPos = 1; + CHECK(locked->IsScndCtrlLockedByMainCtrl()); + CHECK_FALSE(locked->DecScndCtrl(1)); + CHECK_FALSE(locked->DecScndCtrl(2)); + CHECK(locked->ScndCtrlPos == 1); + } + SUBCASE("the master controller taken back from a shunt step drops the shunt") { + controllers_at(locked, resistancefree); + REQUIRE(locked->IncScndCtrl(1)); + if (locked->TrainType == dt_ET22) { + // the ET22's master controller doesn't turn with the shunt on: the shunt goes off first, as before + CHECK_FALSE(locked->DecMainCtrl(1)); + CHECK(locked->MainCtrlPos == resistancefree); + CHECK(locked->DecScndCtrl(1)); + } + CHECK(locked->DecMainCtrl(1)); + CHECK(locked->MainCtrlPos == resistancefree - 1); + CHECK(locked->ScndCtrlPos == 0); + // and the master controller goes on down to zero, nothing left locked + while (locked->MainCtrlPos > 0 && locked->DecMainCtrl(1)) { + } + CHECK(locked->MainCtrlPos == 0); + } + SUBCASE("the master controller set directly (AI, consist) drops the shunt in the next update") { + controllers_at(locked, resistancefree); + REQUIRE(locked->IncScndCtrl(1)); + locked->MainCtrlPos = resistancefree - 1; + locked.step(); + CHECK(locked->ScndCtrlPos == 0); + CHECK(locked->MainCtrlPos == resistancefree - 1); + } + SUBCASE("the master controller moved up from a shunt step onto a resistive position drops the shunt") { + // the last series position, followed by the resistive parallel ones + auto lastseries{0}; + for (auto position{resistancefree}; position > 0 && position < locked->MainCtrlPosNo; position = resistance_free_position(locked.mover(), position)) { + if (locked->RList[position + 1].R >= 0.01) { + lastseries = position; + break; + } + } + REQUIRE(lastseries > 0); + controllers_at(locked, lastseries); + locked->DirActive = 1; + REQUIRE(locked->IncScndCtrl(1)); + if (locked->TrainType == dt_ET22) { + CHECK_FALSE(locked->IncMainCtrl(1)); // the ET22's interlock, as before + CHECK(locked->ScndCtrlPos == 1); + } + else { + CHECK(locked->IncMainCtrl(1)); + CHECK(locked->MainCtrlPos == lastseries + 1); + CHECK(locked->ScndCtrlPos == 0); + } + } + } +} + +TEST_CASE("cntrl: without ScndCtrlResistiveLock the field shunting engages on any position, as before") { + for (auto const *path : {"et22_v3/201e-rn", "ep09_v2/104e"}) { + CAPTURE(path); + vehicle unlocked{definition::fiz(path), 0.0, "test", 1}; + CHECK_FALSE(unlocked->ScndCtrlResistiveLock); + for (auto const position : {0, 1}) { + CAPTURE(position); + controllers_at(unlocked, position); + CHECK_FALSE(unlocked->IsScndCtrlLockedByMainCtrl()); + CHECK(unlocked->IncScndCtrl(1)); + CHECK(unlocked->ScndCtrlPos == 1); + } + } +} diff --git a/vehicle/Driver.cpp b/vehicle/Driver.cpp index b7a9359db..6fb00bc3c 100644 --- a/vehicle/Driver.cpp +++ b/vehicle/Driver.cpp @@ -3472,7 +3472,7 @@ bool TController::IncSpeed() mvOccupied->Vel <= (IsCargoTrain ? 40 : 30) + (seriesmodefieldshunting ? 5 : 0) - (fAccGravity < -0.025 ? 10 : 0)); // when not in series mode use the first available parallel mode configuration until 50/60 km/h for passenger/cargo train // (if there's only one parallel mode configuration it'll be used regardless of current speed) - auto const usefieldshunting = mvControlling->StLinFlag && mvControlling->RList[mvControlling->MainCtrlPos].R < 0.01 && + auto const usefieldshunting = mvControlling->StLinFlag && mvControlling->RList[mvControlling->MainCtrlPos].R < 0.01 && false == mvControlling->IsScndCtrlLockedByMainCtrl() && (useseriesmode ? mvControlling->RList[mvControlling->MainCtrlPos].Bn == 1 : true == sufficientacceleration && true == sufficienttractionforce && mvOccupied->Vel <= (IsCargoTrain ? 60 : 50) + (parallelmodefieldshunting ? 5 : 0) ? mvControlling->RList[mvControlling->MainCtrlPos].Bn > 1 :