diff --git a/McZapkie/MOVER.h b/McZapkie/MOVER.h index 91415ca1d..b619ba7de 100644 --- a/McZapkie/MOVER.h +++ b/McZapkie/MOVER.h @@ -301,6 +301,16 @@ enum class operation_t /// Disable button release transition. disable_off, }; +/// What else the line contactors of a vehicle need before they can close (LineContactorsInterlock in the Cntrl. section). +enum class line_contactors_interlock +{ + /// Nothing more, the legacy behaviour. + none, + /// The converter of the vehicle itself running, where it drives the traction motor fans (ET42). + converter, + /// The traction motor blowers of the vehicle running. + motor_blowers +}; /// Auto-start method for ancillary devices (mutually exclusive). enum class start_t { @@ -2229,6 +2239,8 @@ class TMoverParameters start_t GroundRelayStart{start_t::manual}; // relay activation method bool StLinFlag = false; /*!o styczniki liniowe*/ bool StLinSwitchOff{false}; // state of the button forcing motor connectors open + line_contactors_interlock LineContactorsInterlock{line_contactors_interlock::none}; // what else the line contactors need to close + double LouvresOpenPressure{5.0}; // main reservoir pressure [bar] at which the pneumatic louvres of the motor fans open (ET22) bool ResistorsFlag = false; /*!o jazda rezystorowa*/ double RventRot = 0.0; /*!s obroty wentylatorow rozruchowych*/ double PantographVoltage{0.0}; // voltage supplied to pantographs @@ -2613,6 +2625,19 @@ class TMoverParameters { return JointEngineStart ? range_t::consist : range_t::local; } + // whether the pneumatic louvres of the motor fans are still closed, the main reservoir short of the pressure that opens them + bool LouvresClosed() const + { + return Compressor < LouvresOpenPressure; + } + // whether the devices the line contactors are interlocked with (LineContactorsInterlock) let them close + bool LineContactorsInterlockReleased() const; + // whether the line contactors wait for the converter of the vehicle, switched off with its local switch (converterlocal_sw). + // the AI driver doesn't leave it so: the converters of the other vehicles running, it would wait for the contactors forever + bool LineContactorsHeldByLocalConverterSwitch() const + { + return LineContactorsInterlock == line_contactors_interlock::converter && false == ConverterAllowLocal; + } // whether the vehicle has a driver's cab: it has the driver's brake valve (BrakeHandle in the Cntrl. section of the // .fiz), which the wagons and most cars of the units without a cab don't (a few copy the Cntrl. section of the cab // car, as the EN57 s car does). it's the vehicle type's, unlike the cab the scenario puts a driver in @@ -2683,6 +2708,8 @@ class TMoverParameters void FuelPumpCheck(double const Timestep); void OilPumpCheck(double const Timestep); void MotorBlowersCheck(double const Timestep); + // whether the circuit a traction motor blower runs off has power: the battery, the converter or the main circuit, by its start type + bool MotorBlowerPowerIsAvailable(cooling_fan const &Blower) const; void PantographsCheck(double const Timestep); void LightsCheck(double const Timestep); bool FuseOn(range_t const Notify = range_t::consist); // bezpiecznik nadamiary diff --git a/McZapkie/Mover.cpp b/McZapkie/Mover.cpp index de7f6e0dd..825137675 100644 --- a/McZapkie/Mover.cpp +++ b/McZapkie/Mover.cpp @@ -2406,9 +2406,7 @@ void TMoverParameters::MotorBlowersCheck(double const Timestep) } blower.is_active = // TODO: bind properly power source when ld is in place - (blower.start_type == start_t::battery ? Power24vIsAvailable : - blower.start_type == start_t::converter ? Power110vIsAvailable : - MainCircuitPowered()) // power source + MotorBlowerPowerIsAvailable(blower) // power source // breaker condition disabled until it's implemented in the class data // && ( true == blower.breaker ) && false == disable && @@ -2438,6 +2436,19 @@ void TMoverParameters::MotorBlowersCheck(double const Timestep) } } +bool TMoverParameters::MotorBlowerPowerIsAvailable(cooling_fan const &Blower) const +{ + switch (Blower.start_type) + { + case start_t::battery: + return Power24vIsAvailable; + case start_t::converter: + return Power110vIsAvailable; + default: + return MainCircuitPowered(); + } +} + void TMoverParameters::PantographsCheck(double const /*Timestep*/) { using enum start_t; @@ -7529,7 +7540,30 @@ bool TMoverParameters::MotorConnectorsCheck() auto const connectorsoff{false == Mains || undervoltage || true == FuseFlag || true == StLinSwitchOff || DirActive == 0}; - return false == connectorsoff; + return false == connectorsoff && LineContactorsInterlockReleased(); +} + +bool TMoverParameters::LineContactorsInterlockReleased() const +{ + switch (LineContactorsInterlock) + { + case line_contactors_interlock::converter: + // the converter of this very vehicle, not the 110 V of the trainset: a section with its fans off doesn't start + return ConverterFlag; + case line_contactors_interlock::motor_blowers: + return std::ranges::all_of(MotorBlowers, [this](auto const &Blower) { + if (Blower.min_start_velocity < 0) + { + return Blower.is_active; + } + // a blower which starts with the speed and the motor current (MotorBlowersStartVelocity) can't run before + // the contactors close, nor after a stop longer than it keeps running for: it's enough that it's + // switched on and has power, so it starts once the vehicle moves + return MotorBlowerPowerIsAvailable(Blower) && false == Blower.is_disabled && (Blower.start_type == start_t::manual ? Blower.is_enabled : true); + }); + default: + return true; + } } bool TMoverParameters::OperatePantographsValve(operation_t const State, range_t const Notify) @@ -11675,6 +11709,14 @@ void TMoverParameters::LoadFIZ_Cntrl(std::string const &line) MotorBlowers[end::rear].start_type = lookup != starts.end() ? lookup->second : start_t::manual; MotorBlowers[end::front].start_type = MotorBlowers[end::rear].start_type; } + // what else the line contactors need to close + { + std::map> const interlocks{{"Converter", line_contactors_interlock::converter}, + {"MotorBlowers", line_contactors_interlock::motor_blowers}}; + auto lookup = interlocks.find(extract_value("LineContactorsInterlock", line)); + LineContactorsInterlock = lookup != interlocks.end() ? lookup->second : line_contactors_interlock::none; + } + extract_value(LouvresOpenPressure, "LouvresOpenPressure", line, ""); // compartment lights { auto lookup = starts.find(extract_value("CompartmentLightsStart", line)); diff --git a/application/driverhints.cpp b/application/driverhints.cpp index ae39ede7a..0c6f02cc8 100644 --- a/application/driverhints.cpp +++ b/application/driverhints.cpp @@ -326,6 +326,14 @@ TController::cue_action( driver_hint const Action, float const Actionparameter ) case driver_hint::converteron: { if( AIControllFlag ) { mvOccupied->ConverterSwitch( true ); + // the local switch of the converter too, where the line contactors wait for the vehicle's own converter + // (LineContactorsInterlock): left off by the human driver, that vehicle would never take power + pVehicle->for_each( + coupling::control, + []( TDynamicObject * Vehicle ) { + auto *vehicle { Vehicle->MoverParameters }; + if( vehicle->LineContactorsHeldByLocalConverterSwitch() ) { + vehicle->ConverterAllowLocal = true; } } ); } remove_hint( driver_hint::converteroff ); hint( diff --git a/tests/unit/test_line_contactors_interlock.cpp b/tests/unit/test_line_contactors_interlock.cpp new file mode 100644 index 000000000..a025d4a69 --- /dev/null +++ b/tests/unit/test_line_contactors_interlock.cpp @@ -0,0 +1,315 @@ +#include "stdafx.h" +#include "doctest.h" +#include "consist.h" +#include "drive.h" +#include "vehicle.h" + +#include "McZapkie/hamulce.h" + +// the line contactors interlocked with the fans of the traction motors (eu07/maszyna#460): on the ET42 the fans of a +// section run off its own converter, and with them switched off the line contactors of that section don't close. +// the louvres of the fans of the ET22 open with the air of the main reservoir (eu07/maszyna#451) + +using test::definition; +using test::vehicle; + +namespace { + +// a vehicle whose line contactors could close, but for the interlock +vehicle ready(std::string_view const Interlock) { + auto loaded{definition::load("wagon")}; + if (false == Interlock.empty()) { + loaded.set("Cntrl", "LineContactorsInterlock", std::string{Interlock}); + } + vehicle locomotive{loaded}; + locomotive->Mains = true; + locomotive->DirActive = 1; + locomotive->PipePress = 5.0; + locomotive->BrakePress = 0.0; + return locomotive; +} + +test::track const line{0.15, 0.0, test::catenary_3kv}; + +} // namespace + +TEST_CASE("line contactors interlock: read from the Cntrl. section, none by default") { + CHECK(ready("")->LineContactorsInterlock == line_contactors_interlock::none); + CHECK(ready("Converter")->LineContactorsInterlock == line_contactors_interlock::converter); + CHECK(ready("MotorBlowers")->LineContactorsInterlock == line_contactors_interlock::motor_blowers); + CHECK(ready("Something")->LineContactorsInterlock == line_contactors_interlock::none); +} + +TEST_CASE("line contactors interlock: without one the converter and the blowers don't matter, as before") { + auto locomotive{ready("")}; + locomotive->ConverterFlag = false; + for (auto &blower : locomotive->MotorBlowers) { + blower.is_active = false; + } + CHECK(locomotive->MotorConnectorsCheck()); +} + +TEST_CASE("line contactors interlock: on the converter, they close only with the vehicle's own converter running") { + auto locomotive{ready("Converter")}; + locomotive->ConverterFlag = false; + locomotive->Power110vIsAvailable = true; // the 110 V from the other section doesn't run this one's fans + CHECK_FALSE(locomotive->MotorConnectorsCheck()); + locomotive->ConverterFlag = true; + CHECK(locomotive->MotorConnectorsCheck()); + locomotive->Mains = false; // the other conditions still hold + CHECK_FALSE(locomotive->MotorConnectorsCheck()); +} + +TEST_CASE("line contactors interlock: on the motor blowers, they close only with all of them running") { + auto locomotive{ready("MotorBlowers")}; + locomotive->MotorBlowers[end::front].is_active = true; + locomotive->MotorBlowers[end::rear].is_active = false; + CHECK_FALSE(locomotive->MotorConnectorsCheck()); + locomotive->MotorBlowers[end::rear].is_active = true; + CHECK(locomotive->MotorConnectorsCheck()); +} + +// a blower with MotorBlowersStartVelocity starts with the speed and the motor current, so it can't be running before +// the line contactors close, nor after a stop longer than it keeps running for (MotorBlowersSustainTime): the interlock +// takes it switched on and powered instead, or the vehicle would never take power + +TEST_CASE("line contactors interlock: a blower starting with the speed needs to be switched on and powered, not running") { + auto locomotive{ready("MotorBlowers")}; + for (auto &blower : locomotive->MotorBlowers) { + blower.min_start_velocity = 5.f; + blower.is_enabled = true; // switched on by the driver + blower.is_active = false; // the vehicle stands + } + REQUIRE(locomotive->MotorBlowers[end::front].start_type == start_t::manual); + CHECK(locomotive->MotorConnectorsCheck()); + + auto &rear{locomotive->MotorBlowers[end::rear]}; + SUBCASE("switched off, it holds the contactors open") { + rear.is_disabled = true; + CHECK_FALSE(locomotive->MotorConnectorsCheck()); + } + SUBCASE("not switched on, it holds the contactors open") { + rear.is_enabled = false; + CHECK_FALSE(locomotive->MotorConnectorsCheck()); + } + SUBCASE("off the converter, it needs the 110 V") { + rear.start_type = start_t::converter; + rear.is_enabled = false; // nothing for the driver to switch on + locomotive->Power110vIsAvailable = false; + CHECK_FALSE(locomotive->MotorConnectorsCheck()); + locomotive->Power110vIsAvailable = true; + CHECK(locomotive->MotorConnectorsCheck()); + } + SUBCASE("off the battery, it needs the 24 V") { + rear.start_type = start_t::battery; + locomotive->Power24vIsAvailable = false; + CHECK_FALSE(locomotive->MotorConnectorsCheck()); + locomotive->Power24vIsAvailable = true; + CHECK(locomotive->MotorConnectorsCheck()); + } + SUBCASE("one without a start velocity still has to run") { + rear.min_start_velocity = -1.f; + CHECK_FALSE(locomotive->MotorConnectorsCheck()); + rear.is_active = true; + CHECK(locomotive->MotorConnectorsCheck()); + } +} + +namespace { + +bool blowers_run(TMoverParameters const &Mover) { + return Mover.MotorBlowers[end::front].is_active && Mover.MotorBlowers[end::rear].is_active; +} + +// the driver's first power position, held until the line contactors close (their delay, the pressure switch) +bool close_line_contactors(test::driven const &Driven) { + Driven.controlling.IncMainCtrl(1); + for (int i = 0; i < 30 && false == Driven.controlling.StLinFlag; ++i) { + test::drive(Driven, line, 1.0); + } + return Driven.controlling.StLinFlag; +} + +// the brakes released and the cylinders empty enough for the pressure switch to let the vehicle start +void release(test::driven const &Driven) { + test::release_brakes(Driven.cab); + for (int i = 0; i < 90 && (Driven.controlling.BrakePress > 0.1 || Driven.controlling.PipePress < 4.8); ++i) { + test::drive(Driven, line, 1.0); + } +} + +} // namespace + +TEST_CASE("line contactors interlock: with blowers starting with the speed the vehicle starts from a standstill") { + // each of the circuits a blower runs off has power before the line contactors close + std::string starttype; + SUBCASE("blowers off the converter") { starttype = "Converter"; } + SUBCASE("blowers off the battery") { starttype = "Battery"; } + SUBCASE("blowers switched on by the driver, off the main circuit") { starttype = "Manual"; } + CAPTURE(starttype); + vehicle eu07{definition::fiz("4e_v1/4e") + .set("Cntrl", "LineContactorsInterlock", "MotorBlowers") + .set("Cntrl", "MotorBlowersStart", starttype) + .set("Engine", "MotorBlowersStartVelocity", 5.0) + .set("Engine", "MotorBlowersSustainTime", 10.0), + 0.0, "test", 1}; + auto &mover{eu07.mover()}; + REQUIRE(mover.LineContactorsInterlock == line_contactors_interlock::motor_blowers); + REQUIRE(mover.MotorBlowers[end::front].min_start_velocity == doctest::Approx(5.0)); + REQUIRE(mover.MotorBlowers[end::rear].sustain_time == doctest::Approx(10.0)); + auto driven{test::driving(eu07)}; + REQUIRE(test::start_up(driven, line)); + release(driven); + + // standing, the blowers don't run; the line contactors close all the same and the motors take current + REQUIRE(std::abs(eu07.speed()) < 0.1); + REQUIRE_FALSE(blowers_run(mover)); + CHECK(close_line_contactors(driven)); + CHECK(std::abs(mover.Im) > 0.5); + + // the blowers come on once the vehicle moves + for (int i = 0; i < 6; ++i) { + mover.IncMainCtrl(1); + test::drive(driven, line, 2.0); + } + for (int i = 0; i < 60 && eu07.speed() < 10.0; ++i) { + test::drive(driven, line, 1.0); + } + REQUIRE(eu07.speed() >= 10.0); + CHECK(blowers_run(mover)); + CHECK(mover.StLinFlag); + + // a stop longer than the blowers keep running for + while (mover.DecMainCtrl(1)) { + // down to zero + } + driven.cab.BrakeLevelSet(driven.cab.Handle->GetPos(bh_FB)); + for (int i = 0; i < 120 && std::abs(eu07.speed()) > 0.1; ++i) { + test::drive(driven, line, 1.0); + } + REQUIRE(std::abs(eu07.speed()) <= 0.1); + test::drive(driven, line, 15.0); + REQUIRE_FALSE(blowers_run(mover)); + REQUIRE_FALSE(mover.StLinFlag); + + // and the vehicle starts again + release(driven); + CHECK(close_line_contactors(driven)); + CHECK(std::abs(mover.Im) > 0.5); + for (int i = 0; i < 6; ++i) { + mover.IncMainCtrl(1); + test::drive(driven, line, 2.0); + } + for (int i = 0; i < 60 && eu07.speed() < 10.0; ++i) { + test::drive(driven, line, 1.0); + } + CHECK(eu07.speed() >= 10.0); + CHECK(blowers_run(mover)); +} + +TEST_CASE("line contactors interlock: a blower starting with the speed, switched off on the way, opens the contactors") { + vehicle eu07{definition::fiz("4e_v1/4e") + .set("Cntrl", "LineContactorsInterlock", "MotorBlowers") + .set("Cntrl", "MotorBlowersStart", "Manual") + .set("Engine", "MotorBlowersStartVelocity", 5.0) + .set("Engine", "MotorBlowersSustainTime", 10.0), + 0.0, "test", 1}; + auto &mover{eu07.mover()}; + auto driven{test::driving(eu07)}; + REQUIRE(test::start_up(driven, line)); + release(driven); + REQUIRE(close_line_contactors(driven)); + + // the switch of the rear blower: off, the contactors open and stay open, standing as well as later + REQUIRE(mover.MotorBlowersSwitchOff(true, end::rear)); + test::drive(driven, line, 2.0); + CHECK_FALSE(mover.StLinFlag); + CHECK(std::abs(mover.Im) < 0.5); + while (mover.DecMainCtrl(1)) { + // down to zero + } + test::drive(driven, line, 2.0); + CHECK_FALSE(close_line_contactors(driven)); + + // back on, the vehicle starts + REQUIRE(mover.MotorBlowersSwitchOff(false, end::rear)); + while (mover.DecMainCtrl(1)) { + // down to zero + } + test::drive(driven, line, 2.0); + CHECK(close_line_contactors(driven)); + CHECK(std::abs(mover.Im) > 0.5); +} + +TEST_CASE("line contactors interlock: held by the local converter switch only where they wait for that converter") { + // what the AI driver looks at to switch the converter of a section back on (TController, the converteron hint) + auto interlocked{ready("Converter")}; + CHECK_FALSE(interlocked->LineContactorsHeldByLocalConverterSwitch()); + interlocked->ConverterAllowLocal = false; + CHECK(interlocked->LineContactorsHeldByLocalConverterSwitch()); + + for (auto const *other : {"", "MotorBlowers"}) { + CAPTURE(other); + auto locomotive{ready(other)}; + locomotive->ConverterAllowLocal = false; + CHECK_FALSE(locomotive->LineContactorsHeldByLocalConverterSwitch()); + } +} + +TEST_CASE("line contactors interlock: the ET42 section with its fans switched off doesn't start") { + test::consist et42; + et42.add(definition::fiz("et42_v2/112e-a").set("Cntrl", "LineContactorsInterlock", "Converter"), 1); + et42.add(definition::fiz("et42_v2/112e-b").set("Cntrl", "LineContactorsInterlock", "Converter")); + auto driven{test::driving(et42)}; + REQUIRE(test::start_up(driven, line)); + auto &front{et42[0].mover()}; + auto &rear{et42[1].mover()}; + REQUIRE(front.ConverterFlag); + REQUIRE(rear.ConverterFlag); + + // the fans of the rear section switched off with its own switch, the 110 V of the front one still reaches it + rear.ConverterAllowLocal = false; + test::drive(driven, line, 2.0); + REQUIRE_FALSE(rear.ConverterFlag); + CHECK(rear.Power110vIsAvailable); + + test::release_brakes(driven.cab); + for (int i = 0; i < 3 && driven.cab.DirActive <= 0; ++i) { + driven.cab.DirectionForward(); + } + test::drive(driven, line, 20.0); + driven.controlling.IncMainCtrl(1); + // as the AI does, it waits at the first position for the contactors (their delay, the pressure switch) + for (int i = 0; i < 90 && false == front.StLinFlag; ++i) { + test::drive(driven, line, 1.0); + } + CHECK(front.StLinFlag); + CHECK_FALSE(rear.StLinFlag); + + // the fans back on, the section starts too + rear.ConverterAllowLocal = true; + test::drive(driven, line, 10.0); + REQUIRE(rear.ConverterFlag); + CHECK(rear.StLinFlag); + + // and the fans switched off on the way open its line contactors again + rear.ConverterAllowLocal = false; + test::drive(driven, line, 2.0); + CHECK_FALSE(rear.StLinFlag); + CHECK(front.StLinFlag); +} + +TEST_CASE("louvres: closed until the main reservoir reaches the pressure that opens them") { + vehicle et22{definition::fiz("et22_v3/201e-w")}; + CHECK(et22->LouvresOpenPressure == doctest::Approx(5.0)); // by default + et22->Compressor = 4.9; + CHECK(et22->LouvresClosed()); + et22->Compressor = 5.0; + CHECK_FALSE(et22->LouvresClosed()); + + vehicle given{definition::fiz("et22_v3/201e-w").set("Cntrl", "LouvresOpenPressure", 4.0)}; + given->Compressor = 4.5; + CHECK_FALSE(given->LouvresClosed()); + given->Compressor = 3.9; + CHECK(given->LouvresClosed()); +} diff --git a/vehicle/Driver.cpp b/vehicle/Driver.cpp index a1fc7d30e..eb74344bf 100644 --- a/vehicle/Driver.cpp +++ b/vehicle/Driver.cpp @@ -6600,11 +6600,14 @@ TController::determine_consist_state() { IsAnyConverterPresent = false; IsAnyConverterEnabled = false; IsAnyConverterExplicitlyEnabled = false; + // whether the line contactors of a vehicle wait for its own converter (LineContactorsInterlock), off with its local switch + auto islocalconverterswitchoff { false }; pVehicle->for_each( coupling::control, - [this]( TDynamicObject * Vehicle ) { + [this, &islocalconverterswitchoff]( TDynamicObject * Vehicle ) { auto const *vehicle { Vehicle->MoverParameters }; + islocalconverterswitchoff |= vehicle->LineContactorsHeldByLocalConverterSwitch(); IsAnyConverterOverloadRelayOpen |= vehicle->ConvOvldFlag; IsAnyMotorOverloadRelayOpen |= vehicle->FuseFlag; IsAnyGroundRelayOpen |= !vehicle->GroundRelay; @@ -6675,7 +6678,9 @@ TController::determine_consist_state() { false == IsAnyConverterOverloadRelayOpen && false == IsAnyLineBreakerOpen && ( false == IsAnyConverterPresent || true == IsAnyConverterEnabled ) - && ( false == IsAnyCompressorPresent || true == IsAnyCompressorEnabled ); + && ( false == IsAnyCompressorPresent || true == IsAnyCompressorEnabled ) + // the ai goes back to preparing the engine and switches that converter on, the human driver may run with it off + && ( false == AIControllFlag || false == islocalconverterswitchoff ); } void diff --git a/vehicle/Train.cpp b/vehicle/Train.cpp index ec4bea03d..50659934c 100644 --- a/vehicle/Train.cpp +++ b/vehicle/Train.cpp @@ -9332,6 +9332,7 @@ bool TTrain::Update(double const Deltatime) btLampkaPrzetw.Turn(mvOccupied->Power110vIsAvailable); btLampkaPrzetwOff.Turn(!mvOccupied->Power110vIsAvailable); + btLampkaPrzetwAOff.Turn(!mvControlled->ConverterFlag); btLampkaNadmPrzetw.Turn(Dynamic()->Mechanik ? Dynamic()->Mechanik->IsAnyConverterOverloadRelayOpen : mvControlled->ConvOvldFlag); btLampkaOpory.Turn(mvControlled->StLinFlag && mvControlled->ResistorsFlagCheck()); @@ -9479,6 +9480,7 @@ bool TTrain::Update(double const Deltatime) btLampkaEngineOverheat.Turn(mvControlled->dizel_heat.engine_is_hot); btLampkaMotorBlowers.Turn(mvControlled->MotorBlowers[end::front].is_active && mvControlled->MotorBlowers[end::rear].is_active); btLampkaCoolingFans.Turn(mvControlled->RventRot > 1.0); + btLampkaLouvresClosed.Turn(mvControlled->LouvresClosed()); btLampkaTempomat.Turn(mvOccupied->SpeedCtrlUnit.IsActive); btLampkaDistanceCounter.Turn(m_distancecounter >= 0.f); // universal devices state indicators @@ -9515,6 +9517,7 @@ bool TTrain::Update(double const Deltatime) btLampkaNapNastHam.Turn(false); btLampkaPrzetw.Turn(false); btLampkaPrzetwOff.Turn(false); + btLampkaPrzetwAOff.Turn(false); btLampkaNadmPrzetw.Turn(false); btLampkaSprezarka.Turn(false); btLampkaSprezarkaOff.Turn(false); @@ -9565,6 +9568,7 @@ bool TTrain::Update(double const Deltatime) btLampkaMalfunction.Turn(false); btLampkaMotorBlowers.Turn(false); btLampkaCoolingFans.Turn(false); + btLampkaLouvresClosed.Turn(false); btLampkaTempomat.Turn(false); btLampkaDistanceCounter.Turn(false); // universal devices state indicators @@ -11615,6 +11619,7 @@ void TTrain::clear_cab_controls() btLampkaPrzetw.Clear(); btLampkaPrzetwB.Clear(); btLampkaPrzetwBOff.Clear(); + btLampkaPrzetwAOff.Clear(); btLampkaPrzekRozn.Clear(); btLampkaPrzekRoznPom.Clear(); btLampkaUkrotnienie.Clear(); @@ -11695,6 +11700,7 @@ void TTrain::clear_cab_controls() btLampkaMalfunctionB.Clear(); btLampkaMotorBlowers.Clear(); btLampkaCoolingFans.Clear(); + btLampkaLouvresClosed.Clear(); btLampkaTempomat.Clear(); btLampkaDistanceCounter.Clear(); @@ -12048,6 +12054,7 @@ bool TTrain::initialize_button(cParser &Parser, std::string const &Label, int co {"i-conv_ovld:", btLampkaNadmPrzetw}, {"i-converter:", btLampkaPrzetw}, {"i-converteroff:", btLampkaPrzetwOff}, + {"i-converteraoff:", btLampkaPrzetwAOff}, {"i-converterb:", btLampkaPrzetwB}, {"i-converterboff:", btLampkaPrzetwBOff}, {"i-diff_relay:", btLampkaPrzekRozn}, @@ -12075,6 +12082,7 @@ bool TTrain::initialize_button(cParser &Parser, std::string const &Label, int co {"i-vent_trim:", btLampkaWentZaluzje}, {"i-motorblowers:", btLampkaMotorBlowers}, {"i-coolingfans:", btLampkaCoolingFans}, + {"i-louvresclosed:", btLampkaLouvresClosed}, {"i-tempomat:", btLampkaTempomat}, {"i-distancecounter:", btLampkaDistanceCounter}, {"i-trainheating:", btLampkaOgrzewanieSkladu}, diff --git a/vehicle/Train.h b/vehicle/Train.h index 82d8377d1..a547eef72 100644 --- a/vehicle/Train.h +++ b/vehicle/Train.h @@ -748,6 +748,7 @@ public: // reszta może by?publiczna TButton btLampkaNadmPrzetw; TButton btLampkaPrzetw; TButton btLampkaPrzetwOff; + TButton btLampkaPrzetwAOff; // the converter of this very unit off, where the trainset shares its 110 V (ET42 section fans) TButton btLampkaPrzekRozn; // TODO: implement TButton btLampkaPrzekRoznPom; // TODO: implement TButton btLampkaNadmSil; @@ -854,6 +855,7 @@ public: // reszta może by?publiczna TButton btLampkaMalfunctionB; TButton btLampkaMotorBlowers; TButton btLampkaCoolingFans; + TButton btLampkaLouvresClosed; // ET22, the pneumatic louvres of the motor fans not open yet TButton btLampkaTempomat; TButton btLampkaDistanceCounter;