public virtual void UpdateTripleValveState(float controlPressurePSI)
{
if (BrakeLine1PressurePSI < FullServPressurePSI - 1)
{
TripleValveState = ValveState.Emergency;
}
else if (BrakeLine1PressurePSI > AuxResPressurePSI + 1)
{
TripleValveState = ValveState.Release;
}
else if (TripleValveState == ValveState.Emergency && BrakeLine1PressurePSI > AuxResPressurePSI)
{
TripleValveState = ValveState.Release;
}
else if (EmergResPressurePSI > 70 && BrakeLine1PressurePSI > EmergResPressurePSI * 0.97f) // UIC regulation: for 5 bar systems, release if > 4.85 bar
{
TripleValveState = ValveState.Release;
}
else if (TripleValveState != ValveState.Emergency && BrakeLine1PressurePSI < AuxResPressurePSI - 1)
{
TripleValveState = ValveState.Apply;
}
else if (TripleValveState == ValveState.Apply && BrakeLine1PressurePSI >= AuxResPressurePSI)
{
TripleValveState = ValveState.Lap;
}
}
private ValveControl GetValveControl(ValveState valveState)
{
var pressureContainerState = valveState == ValveState.Closed || valveState == ValveState.Opening
? PressureContainerState.Closed
: PressureContainerState.Open;
_pressureContainer.PressureContainerState.Returns(pressureContainerState);
return(new ValveControl(_pressureContainer));
}
public override void Stop()
{
state = ValveState.right;
for (int i = 0; i < componentsToAnimate.Length; ++i)
{
componentsToAnimate[i].position = originalPositions[i];
}
originalPositions = null;
simulating = false;
}
public override void Setup()
{
state = ValveState.right;
originalPositions = new Vector3[componentsToAnimate.Length];
for (int i = 0; i < componentsToAnimate.Length; ++i)
{
originalPositions[i] = componentsToAnimate[i].position;
}
simulating = true;
}
public void Close()
{
if (ValveState == ValveState.Open)
{
ValveState = ValveState.Closing;
Task.Delay(OpenCloseDelayInMs).ContinueWith(t =>
{
ValveState = ValveState.Closed;
_pressureContainer.SetState(PressureContainerState.Closed);
});
}
}
public bool SetValveState(int valveNum, ValveState valveState)
{
switch (valveNum)
{
case 1:
_valve1 = valveState;
return true;
case 2:
_valve2 = valveState;
return true;
default:
return false;
}
}
public void ChangeValveState(ValveState state)
{
switch (state)
{
case ValveState.ON:
{
ValveToggle.isOn = true;
}
break;
case ValveState.OFF:
{
ValveToggle.isOn = false;
}
break;
}
}
public override void Restore(BinaryReader inf)
{
BrakeLine1PressurePSI = inf.ReadSingle();
BrakeLine2PressurePSI = inf.ReadSingle();
BrakeLine3PressurePSI = inf.ReadSingle();
HandbrakePercent = inf.ReadSingle();
ReleaseRatePSIpS = inf.ReadSingle();
RetainerPressureThresholdPSI = inf.ReadSingle();
AutoCylPressurePSI = inf.ReadSingle();
AuxResPressurePSI = inf.ReadSingle();
EmergResPressurePSI = inf.ReadSingle();
FullServPressurePSI = inf.ReadSingle();
TripleValveState = (ValveState)inf.ReadInt32();
FrontBrakeHoseConnected = inf.ReadBoolean();
AngleCockAOpen = inf.ReadBoolean();
AngleCockBOpen = inf.ReadBoolean();
BleedOffValveOpen = inf.ReadBoolean();
HoldingValve = (ValveState)inf.ReadInt32();
CylVolumeM3 = inf.ReadSingle();
}
public override void InitializeFromCopy(BrakeSystem copy)
{
AirSinglePipe thiscopy = (AirSinglePipe)copy;
MaxHandbrakeForceN = thiscopy.MaxHandbrakeForceN;
MaxBrakeForceN = thiscopy.MaxBrakeForceN;
MaxCylPressurePSI = thiscopy.MaxCylPressurePSI;
AuxCylVolumeRatio = thiscopy.AuxCylVolumeRatio;
AuxBrakeLineVolumeRatio = thiscopy.AuxBrakeLineVolumeRatio;
EmergResVolumeM3 = thiscopy.EmergResVolumeM3;
RetainerPressureThresholdPSI = thiscopy.RetainerPressureThresholdPSI;
ReleaseRatePSIpS = thiscopy.ReleaseRatePSIpS;
MaxReleaseRatePSIpS = thiscopy.MaxReleaseRatePSIpS;
MaxApplicationRatePSIpS = thiscopy.MaxApplicationRatePSIpS;
MaxAuxilaryChargingRatePSIpS = thiscopy.MaxAuxilaryChargingRatePSIpS;
EmergResChargingRatePSIpS = thiscopy.EmergResChargingRatePSIpS;
EmergAuxVolumeRatio = thiscopy.EmergAuxVolumeRatio;
TwoPipes = thiscopy.TwoPipes;
NoMRPAuxResCharging = thiscopy.NoMRPAuxResCharging;
HoldingValve = thiscopy.HoldingValve;
}
public override void Initialize(bool handbrakeOn, float maxPressurePSI, float fullServPressurePSI, bool immediateRelease)
{
// reducing size of Emergency Reservoir for short (fake) cars
if (Car.Simulator.Settings.CorrectQuestionableBrakingParams && Car.CarLengthM <= 1)
{
EmergResVolumeM3 = Math.Min(0.02f, EmergResVolumeM3);
}
BrakeLine1PressurePSI = Car.Train.BrakeLine1PressurePSIorInHg;
BrakeLine2PressurePSI = Car.Train.BrakeLine2PressurePSI;
BrakeLine3PressurePSI = 0;
AuxResPressurePSI = maxPressurePSI > BrakeLine1PressurePSI ? maxPressurePSI : BrakeLine1PressurePSI;
if ((Car as MSTSWagon).EmergencyReservoirPresent || maxPressurePSI > 0)
{
EmergResPressurePSI = maxPressurePSI;
}
FullServPressurePSI = fullServPressurePSI;
AutoCylPressurePSI = immediateRelease ? 0 : Math.Min((maxPressurePSI - BrakeLine1PressurePSI) * AuxCylVolumeRatio, MaxCylPressurePSI);
TripleValveState = ValveState.Lap;
HoldingValve = ValveState.Release;
HandbrakePercent = handbrakeOn & (Car as MSTSWagon).HandBrakePresent ? 100 : 0;
SetRetainer(RetainerSetting.Exhaust);
MSTSLocomotive loco = Car as MSTSLocomotive;
if (loco != null)
{
loco.MainResPressurePSI = loco.MaxMainResPressurePSI;
}
if (EmergResVolumeM3 > 0 && EmergAuxVolumeRatio > 0 && BrakePipeVolumeM3 > 0)
{
AuxBrakeLineVolumeRatio = EmergResVolumeM3 / EmergAuxVolumeRatio / BrakePipeVolumeM3;
}
else
{
AuxBrakeLineVolumeRatio = 3.1f;
}
//FullCylAirConsumedM3 = MaxCylPressurePSI * MaxBrakeForceN * 0.00000059733491f; //an average volume (M3) of air used in brake cylinder for 1 N brake force.;
CylVolumeM3 = EmergResVolumeM3 / EmergAuxVolumeRatio / AuxCylVolumeRatio;
}
public static ValveState GetState(string Input)
{
ValveState retval = ValveState.Close;
if (Input == "0")
{
retval = ValveState.Close;
}
if (Input == "1")
{
retval = ValveState.Open;
}
if (Input == "2")
{
retval = ValveState.Undefine;
}
if (Input == "3")
{
retval = ValveState.Error;
}
return(retval);
}
void LateUpdate()
{
if (simulating)
{
PneumaticSolenoid leftSolenoid = componentReferences.solenoidList[0];
PneumaticSolenoid rightSolenoid = componentReferences.solenoidList[1];
if (leftSolenoid.active && !rightSolenoid.active)
{
if (state != ValveState.left)
{
state = ValveState.left;
for (int i = 0; i < componentsToAnimate.Length; ++i)
{
componentsToAnimate[i].position = originalPositions[i] + transform.right * shiftAmount;
}
}
}
else if (!leftSolenoid.active && rightSolenoid.active)
{
if (state != ValveState.right)
{
state = ValveState.right;
for (int i = 0; i < componentsToAnimate.Length; ++i)
{
componentsToAnimate[i].position = originalPositions[i] - transform.right * shiftAmount;
}
}
}
else if (state != ValveState.middle)
{
state = ValveState.middle;
for (int i = 0; i < componentsToAnimate.Length; ++i)
{
componentsToAnimate[i].position = originalPositions[i];
}
}
}
}
private bool SetValveState(int valveNum, ValveState valveState)
{
if (IsConnected == false) return false;
LogService.AddLog(LogType.Notice, "벨브[" + valveNum + "]제어: " + valveState.ToString());
switch (valveNum)
{
case 1:
return true;
case 2:
return true;
default:
LogService.AddLog(LogType.Warnning, "비정상 벨브제어시도, 벨브번호: " + valveNum);
return false;
}
}
public virtual void CloseValve()
{
ValveState = ValveState.Closed;
}
public ValveControl(IPressureContainer pressureContainer)
{
_pressureContainer = pressureContainer;
this.ValveState = _pressureContainer.PressureContainerState == PressureContainerState.Open ?
ValveState.Open : ValveState.Closed;
}
public bool SetValveState(int valveNum, ValveState valveState)
{
throw new NotImplementedException();
}
public override void Update(float elapsedClockSeconds)
{
//ValveState prevTripleValueState = TripleValveState;
// Emergency reservoir's second role (in OpenRails) is to act as a control reservoir,
// maintaining a reference control pressure for graduated release brake actions.
// Thus this pressure must be set even in brake systems ER not present otherwise. It just stays static in this case.
float threshold = Math.Max(RetainerPressureThresholdPSI,
(Car as MSTSWagon).DistributorPresent ? (EmergResPressurePSI - BrakeLine1PressurePSI) * AuxCylVolumeRatio : 0);
if (BleedOffValveOpen)
{
if (AuxResPressurePSI < 0.01f && AutoCylPressurePSI < 0.01f && BrakeLine1PressurePSI < 0.01f && (EmergResPressurePSI < 0.01f || !(Car as MSTSWagon).EmergencyReservoirPresent))
{
BleedOffValveOpen = false;
}
else
{
AuxResPressurePSI -= elapsedClockSeconds * MaxApplicationRatePSIpS;
if (AuxResPressurePSI < 0)
{
AuxResPressurePSI = 0;
}
AutoCylPressurePSI -= elapsedClockSeconds * MaxReleaseRatePSIpS;
if (AutoCylPressurePSI < 0)
{
AutoCylPressurePSI = 0;
}
if ((Car as MSTSWagon).EmergencyReservoirPresent)
{
EmergResPressurePSI -= elapsedClockSeconds * EmergResChargingRatePSIpS;
if (EmergResPressurePSI < 0)
{
EmergResPressurePSI = 0;
}
}
TripleValveState = ValveState.Release;
}
}
else
{
UpdateTripleValveState(threshold);
}
if (TripleValveState == ValveState.Apply || TripleValveState == ValveState.Emergency)
{
float dp = elapsedClockSeconds * MaxApplicationRatePSIpS;
if (AuxResPressurePSI - dp / AuxCylVolumeRatio < AutoCylPressurePSI + dp)
{
dp = (AuxResPressurePSI - AutoCylPressurePSI) * AuxCylVolumeRatio / (1 + AuxCylVolumeRatio);
}
if (TwoPipes && dp > threshold - AutoCylPressurePSI)
{
dp = threshold - AutoCylPressurePSI;
}
if (AutoCylPressurePSI + dp > MaxCylPressurePSI)
{
dp = MaxCylPressurePSI - AutoCylPressurePSI;
}
if (BrakeLine1PressurePSI > AuxResPressurePSI - dp / AuxCylVolumeRatio && !BleedOffValveOpen)
{
dp = (AuxResPressurePSI - BrakeLine1PressurePSI) * AuxCylVolumeRatio;
}
AuxResPressurePSI -= dp / AuxCylVolumeRatio;
AutoCylPressurePSI += dp;
if (TripleValveState == ValveState.Emergency && (Car as MSTSWagon).EmergencyReservoirPresent)
{
dp = elapsedClockSeconds * MaxApplicationRatePSIpS;
if (EmergResPressurePSI - dp < AuxResPressurePSI + dp * EmergAuxVolumeRatio)
{
dp = (EmergResPressurePSI - AuxResPressurePSI) / (1 + EmergAuxVolumeRatio);
}
EmergResPressurePSI -= dp;
AuxResPressurePSI += dp * EmergAuxVolumeRatio;
}
}
if (TripleValveState == ValveState.Release && HoldingValve == ValveState.Release)
{
if (AutoCylPressurePSI > threshold)
{
AutoCylPressurePSI -= elapsedClockSeconds * ReleaseRatePSIpS;
if (AutoCylPressurePSI < threshold)
{
AutoCylPressurePSI = threshold;
}
}
if ((Car as MSTSWagon).EmergencyReservoirPresent)
{
if (!(Car as MSTSWagon).DistributorPresent && AuxResPressurePSI < EmergResPressurePSI && AuxResPressurePSI < BrakeLine1PressurePSI)
{
float dp = elapsedClockSeconds * EmergResChargingRatePSIpS;
if (EmergResPressurePSI - dp < AuxResPressurePSI + dp * EmergAuxVolumeRatio)
{
dp = (EmergResPressurePSI - AuxResPressurePSI) / (1 + EmergAuxVolumeRatio);
}
if (BrakeLine1PressurePSI < AuxResPressurePSI + dp * EmergAuxVolumeRatio)
{
dp = (BrakeLine1PressurePSI - AuxResPressurePSI) / EmergAuxVolumeRatio;
}
EmergResPressurePSI -= dp;
AuxResPressurePSI += dp * EmergAuxVolumeRatio;
}
if (AuxResPressurePSI > EmergResPressurePSI)
{
float dp = elapsedClockSeconds * EmergResChargingRatePSIpS;
if (EmergResPressurePSI + dp > AuxResPressurePSI - dp * EmergAuxVolumeRatio)
{
dp = (AuxResPressurePSI - EmergResPressurePSI) / (1 + EmergAuxVolumeRatio);
}
EmergResPressurePSI += dp;
AuxResPressurePSI -= dp * EmergAuxVolumeRatio;
}
}
if (AuxResPressurePSI < BrakeLine1PressurePSI && (!TwoPipes || NoMRPAuxResCharging || BrakeLine2PressurePSI < BrakeLine1PressurePSI))
{
float dp = elapsedClockSeconds * MaxAuxilaryChargingRatePSIpS;
if (AuxResPressurePSI + dp > BrakeLine1PressurePSI - dp * AuxBrakeLineVolumeRatio)
{
dp = (BrakeLine1PressurePSI - AuxResPressurePSI) / (1 + AuxBrakeLineVolumeRatio);
}
AuxResPressurePSI += dp;
BrakeLine1PressurePSI -= dp * AuxBrakeLineVolumeRatio;
}
}
if (TwoPipes &&
!NoMRPAuxResCharging &&
AuxResPressurePSI < BrakeLine2PressurePSI &&
AuxResPressurePSI < EmergResPressurePSI &&
(BrakeLine2PressurePSI > BrakeLine1PressurePSI || TripleValveState != ValveState.Release))
{
float dp = elapsedClockSeconds * MaxAuxilaryChargingRatePSIpS;
if (AuxResPressurePSI + dp > BrakeLine2PressurePSI - dp * AuxBrakeLineVolumeRatio)
{
dp = (BrakeLine2PressurePSI - AuxResPressurePSI) / (1 + AuxBrakeLineVolumeRatio);
}
AuxResPressurePSI += dp;
BrakeLine2PressurePSI -= dp * AuxBrakeLineVolumeRatio;
}
if (BrakeLine3PressurePSI >= 1000) // a really weird method: instead of getting the state of bailoff control here, the engine brake simulation signals the bailoff state with brakelinepressure3=1000
{
BrakeLine3PressurePSI -= 1000;
AutoCylPressurePSI -= MaxReleaseRatePSIpS * elapsedClockSeconds;
}
if (AutoCylPressurePSI < 0)
{
AutoCylPressurePSI = 0;
}
if (AutoCylPressurePSI < BrakeLine3PressurePSI)
{
CylPressurePSI = BrakeLine3PressurePSI;
}
else
{
CylPressurePSI = AutoCylPressurePSI;
}
float f = MaxBrakeForceN * Math.Min(CylPressurePSI / MaxCylPressurePSI, 1);
if (f < MaxHandbrakeForceN * HandbrakePercent / 100)
{
f = MaxHandbrakeForceN * HandbrakePercent / 100;
}
Car.BrakeForceN = f;
// sound trigger checking runs every half second, to avoid the problems caused by the jumping BrakeLine1PressurePSI value, and also saves cpu time :)
if (SoundTriggerCounter >= 0.5f)
{
SoundTriggerCounter = 0f;
if (Math.Abs(AutoCylPressurePSI - prevCylPressurePSI) > 0.1f) //(AutoCylPressurePSI != prevCylPressurePSI)
{
if (!TrainBrakePressureChanging)
{
if (AutoCylPressurePSI > prevCylPressurePSI)
{
Car.SignalEvent(Event.TrainBrakePressureIncrease);
}
else
{
Car.SignalEvent(Event.TrainBrakePressureDecrease);
}
TrainBrakePressureChanging = !TrainBrakePressureChanging;
}
}
else if (TrainBrakePressureChanging)
{
TrainBrakePressureChanging = !TrainBrakePressureChanging;
Car.SignalEvent(Event.TrainBrakePressureStoppedChanging);
}
if (Math.Abs(BrakeLine1PressurePSI - prevBrakePipePressurePSI) > 0.1f /*BrakeLine1PressurePSI > prevBrakePipePressurePSI*/)
{
if (!BrakePipePressureChanging)
{
if (BrakeLine1PressurePSI > prevBrakePipePressurePSI)
{
Car.SignalEvent(Event.BrakePipePressureIncrease);
}
else
{
Car.SignalEvent(Event.BrakePipePressureDecrease);
}
BrakePipePressureChanging = !BrakePipePressureChanging;
}
}
else if (BrakePipePressureChanging)
{
BrakePipePressureChanging = !BrakePipePressureChanging;
Car.SignalEvent(Event.BrakePipePressureStoppedChanging);
}
prevCylPressurePSI = AutoCylPressurePSI;
prevBrakePipePressurePSI = BrakeLine1PressurePSI;
}
SoundTriggerCounter = SoundTriggerCounter + elapsedClockSeconds;
}
public MockGasTankConnector(bool connected, ValveState v1State, ValveState v2State)
{
_connected = connected;
_valve1 = v1State;
_valve2 = v2State;
}
public bool SetValveState(int valveNum, ValveState valveState)
{
return _connector.SetValveState(valveNum, valveState);
}
public void InitParam(string drumID)
{
this._drumId = drumID;
ID.text = "ID: " + drumID;
curValveState = ValveToggle.isOn ? ValveState.ON : ValveState.OFF;
}
public virtual void CloseValve()
{
ValveState = ValveState.Closed;
}
