Merge pull request #444 from peternewell/brake-enhancements

First phase of wheel slide protection
http://www.elvastower.com/forums/index.php?/topic/35332-more-brake-enhancements/

Author: cjakeman

Source/Documentation/Manual/physics.rst

@@ -2894,6 +2894,8 @@ MaxAuxilaryChargingRate and EmergencyResChargingRate.
 - ``Engine(ORTSBrakePipeTimeFactor`` -- Time in seconds for a difference in
   pipe pressure between adjacent cars to equalize to about 1/3
   (default .003).
+- ``Engine(AirBrakeMaxMainResPipePressure`` -- Pressure in Main Reservoir 
+  Pipe for twin pipe braking systems (default = Main Reservoir Pressure).
 
 .. _physics-retainers:
 
@@ -3193,6 +3195,30 @@ To control the application and release rates on the brake use the ``EngineBrakes
 The ``SteamBrakeFX`` special effect, if added to the wagon, will turn on and off with the brake operation 
 and can be used to model steam leakage of the steam brake cylinder, etc.
 
+Wheel Slide Protection
+----------------------
+
+Open Rails supports the use of Wheel Slide Protection (WSP) on trains with air brakes. WSP operates as described below.
+
+During braking wheelslide control is effected throughout the train by additional equipment on each vehicle. In the piping to each 
+pair of brake cylinders are fitted electrically operated dump valves. When axle rotations which are sensed electrically, differ 
+by a predetermined speed the dump valves are operated releasing brake cylinder pressure to both axles of the affected bogie.
+
+Dump valve operation will cease when differences in axle rotations are within specified limits or the axle accelerates faster than 
+a specified rate. The dump valve will only operate for a maximum period of seven seconds after which time it will be de-energised 
+and the dump valve will not re-operate until the train has stopped or the throttle operated. 
+
+Dump valve operation is prevented under the following conditions:
+
+- When the Power Controller is open.
+- When Brake Pipe Pressure has been reduced below 36 psi (250 kPa).
+
+To enable WSP ``ORTSWheelBrakeSlideProtection (1)``. If it is desired that emergency braking should not be impacted by WSP, then use 
+the ``ORTSEmergencyBrakingDisablesWSP (1)`` parameter.
+
+When WSP is active the brake cylinder pressure reading will go yellow in the extended HuD on the BRAKE INFORMATION screen.
+
+
 Dynamically Evolving Tractive Force
 ===================================
 

Source/Orts.Formats.Msts/CabViewFile.cs

@@ -72,6 +72,7 @@ public enum CABViewControlTypes
         NONE,
         SPEEDOMETER,
         MAIN_RES,
+        MAIN_RES_PIPE,
         EQ_RES,
         BRAKE_CYL,
         BRAKE_PIPE,

Source/Orts.Simulation/Common/Events.cs

@@ -240,6 +240,10 @@ public enum Event
         HeatingOn,
         AirConditioningOff,
         AirConditioningOn,
+
+        OverchargeBrakingOn,
+        OverchargeBrakingOff,
+
     }
 
     public static class Events
@@ -496,6 +500,9 @@ public static Event From(bool mstsBinEnabled, Source source, int eventID)
                         case 234: return Event.AirConditioningOn;
                         case 235: return Event.AirConditioningOff;
 
+                        case 250: return Event.OverchargeBrakingOn;
+                        case 251: return Event.OverchargeBrakingOff;
+
                         default: return 0;
                     }
                 case Source.MSTSCrossing:

Source/Orts.Simulation/Simulation/Physics/Train.cs

@@ -3835,7 +3835,7 @@ public void UnconditionalInitializeBrakes()
                     if (MUDynamicBrakePercent == 0)
                         MUDynamicBrakePercent = -1;
                 }
-                BrakeLine2PressurePSI = maxPressurePSI;
+                BrakeLine2PressurePSI = lead.MaximumMainReservoirPipePressurePSI;
                 ConnectBrakeHoses();
             }
             else

Source/Orts.Simulation/Simulation/RollingStocks/MSTSLocomotive.cs

@@ -131,6 +131,7 @@ public enum SoundState
         public float MaxSpeedMpS = 1e3f;
         public float UnloadingSpeedMpS;
         public float MainResPressurePSI = 130;
+        public float MaximumMainReservoirPipePressurePSI;
         public bool CompressorIsOn;
         public float AverageForceN;
         public float PowerOnDelayS;
@@ -353,6 +354,7 @@ public float OdometerM
         public float DynamicBrakeDelayS;
         public bool DynamicBrakeAutoBailOff;
         public bool UsingRearCab;
+        public bool BrakeOverchargeSoundOn = false;
 
         protected bool DynamicBrakeBlended; // dynamic brake blending is currently active
         protected bool DynamicBrakeBlendingEnabled; // dynamic brake blending is configured
@@ -843,6 +845,7 @@ public override void Parse(string lowercasetoken, STFReader stf)
                 case "engine(enginecontrollers(combined_control": ParseCombData(lowercasetoken, stf); break;
                 case "engine(airbrakesmainresvolume": MainResVolumeM3 = Me3.FromFt3(stf.ReadFloatBlock(STFReader.UNITS.VolumeDefaultFT3, null)); break;
                 case "engine(airbrakesmainmaxairpressure": MainResPressurePSI = MaxMainResPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;
+                case "engine(airbrakemaxmainrespipepressure": MaximumMainReservoirPipePressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;
                 case "engine(airbrakescompressorrestartpressure": CompressorRestartPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;
                 case "engine(airbrakesaircompressorpowerrating": CompressorChargingRateM3pS = Me3.FromFt3(stf.ReadFloatBlock(STFReader.UNITS.VolumeDefaultFT3, null)); break;
                 case "engine(trainpipeleakrate": TrainBrakePipeLeakPSIorInHgpS = stf.ReadFloatBlock(STFReader.UNITS.PressureRateDefaultPSIpS, null); break;
@@ -1027,7 +1030,8 @@ public override void Copy(MSTSWagon copy)
             CompressorRestartPressurePSI = locoCopy.CompressorRestartPressurePSI;
             TrainBrakePipeLeakPSIorInHgpS = locoCopy.TrainBrakePipeLeakPSIorInHgpS;
             MaxMainResPressurePSI = locoCopy.MaxMainResPressurePSI;
-            MainResPressurePSI = MaxMainResPressurePSI;
+            MainResPressurePSI = locoCopy.MaxMainResPressurePSI;
+            MaximumMainReservoirPipePressurePSI = locoCopy.MaximumMainReservoirPipePressurePSI;
             MainResVolumeM3 = locoCopy.MainResVolumeM3;
             MainResChargingRatePSIpS = locoCopy.MainResChargingRatePSIpS;
             BrakePipeDischargeTimeFactor = locoCopy.BrakePipeDischargeTimeFactor;
@@ -1392,6 +1396,11 @@ public override void Initialize()
                 }
             }
 
+            if (MaximumMainReservoirPipePressurePSI == 0)
+            {
+                MaximumMainReservoirPipePressurePSI = MaxMainResPressurePSI;
+            }
+
             // Check TrainBrakesControllerMaxSystemPressure parameter for "correct" value 
             // This is only done for vacuum brakes as the UoM can be confusing - it defaults to psi due to way parameter is read, and if units are entered then a InHG value can be incorrectly converted.
             if ((BrakeSystem is VacuumSinglePipe))
@@ -4444,6 +4453,11 @@ public virtual float GetDataOf(CabViewControl cvc)
                         data = ConvertFromPSI(cvc, MainResPressurePSI);
                         break;
                     }
+                case CABViewControlTypes.MAIN_RES_PIPE:
+                    {
+                        data = ConvertFromPSI(cvc, this.BrakeSystem.BrakeLine2PressurePSI);
+                        break;
+                    }
                 case CABViewControlTypes.BRAKE_PIPE:
                     {
                         data = ConvertFromPSI(cvc, this.BrakeSystem.BrakeLine1PressurePSI);

Source/Orts.Simulation/Simulation/RollingStocks/MSTSWagon.cs

@@ -1068,6 +1068,30 @@ public virtual void Parse(string lowercasetoken, STFReader stf)
                 case "wagon(ortsbrakeshoefriction": BrakeShoeFrictionFactor = new Interpolator(stf); break;
                 case "wagon(maxhandbrakeforce": InitialMaxHandbrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, null); break;
                 case "wagon(maxbrakeforce": InitialMaxBrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, null); break;
+                case "wagon(ortswheelbrakeslideprotection":
+                  // stf.MustMatch("(");
+                    var brakeslideprotection = stf.ReadFloatBlock(STFReader.UNITS.None, null);
+                    if (brakeslideprotection == 1)
+                    {
+                        WheelBrakeSlideProtectionFitted = true;
+                    }
+                    else
+                    {
+                        WheelBrakeSlideProtectionFitted = false;
+                    }
+                    break;
+                case "wagon(ortswheelbrakesslideprotectionlimitdisable":
+                    // stf.MustMatch("(");
+                    var brakeslideprotectiondisable = stf.ReadFloatBlock(STFReader.UNITS.None, null);
+                    if (brakeslideprotectiondisable == 1)
+                    {
+                        WheelBrakeSlideProtectionLimitDisabled = true;
+                    }
+                    else
+                    {
+                        WheelBrakeSlideProtectionLimitDisabled = false;
+                    }
+                    break;
                 case "wagon(ortsdavis_a": DavisAN = stf.ReadFloatBlock(STFReader.UNITS.Force, null); break;
                 case "wagon(ortsdavis_b": DavisBNSpM = stf.ReadFloatBlock(STFReader.UNITS.Resistance, null); break;
                 case "wagon(ortsdavis_c": DavisCNSSpMM = stf.ReadFloatBlock(STFReader.UNITS.ResistanceDavisC, null); break;
@@ -1458,6 +1482,8 @@ public virtual void Copy(MSTSWagon copy)
             DriverWheelRadiusM = copy.DriverWheelRadiusM;
             MainSoundFileName = copy.MainSoundFileName;
             BrakeShoeFrictionFactor = copy.BrakeShoeFrictionFactor;
+            WheelBrakeSlideProtectionFitted = copy.WheelBrakeSlideProtectionFitted;
+            WheelBrakeSlideProtectionLimitDisabled = copy.WheelBrakeSlideProtectionLimitDisabled;
             InitialMaxBrakeForceN = copy.InitialMaxBrakeForceN;
             InitialMaxHandbrakeForceN = copy.InitialMaxHandbrakeForceN;
             MaxBrakeForceN = copy.MaxBrakeForceN;
@@ -1680,6 +1706,9 @@ public override void Save(BinaryWriter outf)
             outf.Write(CarInsideTempC);
             outf.Write(CurrentCarSteamHeatBoilerWaterCapacityL);
 
+            outf.Write(WheelBrakeSlideProtectionActive);
+            outf.Write(WheelBrakeSlideProtectionTimerS);
+
             base.Save(outf);
         }
 
@@ -1724,6 +1753,9 @@ public override void Restore(BinaryReader inf)
             CarInsideTempC = inf.ReadSingle();
             CurrentCarSteamHeatBoilerWaterCapacityL = inf.ReadSingle();
 
+            WheelBrakeSlideProtectionActive = inf.ReadBoolean();
+            WheelBrakeSlideProtectionTimerS = inf.ReadInt32();
+
             base.Restore(inf);
         }
 

Source/Orts.Simulation/Simulation/RollingStocks/SubSystems/Brakes/MSTS/AirSinglePipe.cs

@@ -144,7 +144,7 @@ public override string[] GetDebugStatus(Dictionary<BrakeSystemComponent, Pressur
         {
             return new string[] {
                 DebugType,
-                FormatStrings.FormatPressure(CylPressurePSI, PressureUnit.PSI, units[BrakeSystemComponent.BrakeCylinder], true),
+                string.Format("{0}{1}",FormatStrings.FormatPressure(CylPressurePSI, PressureUnit.PSI, units[BrakeSystemComponent.BrakeCylinder], true), (Car as MSTSWagon).WheelBrakeSlideProtectionActive ? "???" : ""),
                 FormatStrings.FormatPressure(BrakeLine1PressurePSI, PressureUnit.PSI, units[BrakeSystemComponent.BrakePipe], true),
                 FormatStrings.FormatPressure(AuxResPressurePSI, PressureUnit.PSI, units[BrakeSystemComponent.AuxiliaryReservoir], true),
                 (Car as MSTSWagon).EmergencyReservoirPresent ? FormatStrings.FormatPressure(EmergResPressurePSI, PressureUnit.PSI, units[BrakeSystemComponent.EmergencyReservoir], true) : string.Empty,
@@ -377,7 +377,7 @@ public override void Update(float elapsedClockSeconds)
                 UpdateTripleValveState(threshold);
 
             // triple valve is set to charge the brake cylinder
-            if (TripleValveState == ValveState.Apply || TripleValveState == ValveState.Emergency)
+            if ((TripleValveState == ValveState.Apply || TripleValveState == ValveState.Emergency) && !Car.WheelBrakeSlideProtectionActive)
             {
                 float dp = elapsedClockSeconds * MaxApplicationRatePSIpS;
                 if (AuxResPressurePSI - dp / AuxCylVolumeRatio < AutoCylPressurePSI + dp)
@@ -452,6 +452,8 @@ public override void Update(float elapsedClockSeconds)
                     BrakeLine1PressurePSI += dp * AuxBrakeLineVolumeRatio;
                 }
             }
+
+            // Charge Auxiliary reservoir for MRP
             if (TwoPipes
                 && !NoMRPAuxResCharging
                 && AuxResPressurePSI < BrakeLine2PressurePSI
@@ -487,6 +489,45 @@ public override void Update(float elapsedClockSeconds)
             else
                 CylPressurePSI = AutoCylPressurePSI;
 
+            // During braking wheelslide control is effected throughout the train by additional equipment on each vehicle. In the piping to each pair of brake cylinders are fitted electrically operated 
+            // dump valves. When axle rotations which are sensed electrically, differ by a predetermined speed the dump valves are operated releasing brake cylinder pressure to both axles of the affected 
+            // bogie.
+
+            // Dump valve operation will cease when differences in axle rotations arewithin specified limits or the axle accelerates faster than a specified rate. The dump valve resets whenever the wheel
+            // creep speed drops to normal. The dump valve will only operate continuously for a maximum period of seven seconds after which time it will be de-energised and the dump valve will not 
+            // re-operate until the train has stopped or the throttle operated. 
+
+            // Dump valve operation is prevented under the following conditions:-
+            // (i) When the Power Controller is open.
+
+            // (ii) When Brake Pipe Pressure has been reduced below 250 kPa (36.25psi). 
+
+            if (Car.WheelBrakeSlideProtectionFitted && Car.Train.IsPlayerDriven)
+            {
+                // WSP dump valve active
+                if ((Car.BrakeSkidWarning || Car.BrakeSkid) && CylPressurePSI > 0 && !Car.WheelBrakeSlideProtectionDumpValveLockout && ( (!Car.WheelBrakeSlideProtectionLimitDisabled && BrakeLine1PressurePSI > 36.25) || Car.WheelBrakeSlideProtectionLimitDisabled) )
+                {
+                    Car.WheelBrakeSlideProtectionActive = true;
+                    AutoCylPressurePSI -= elapsedClockSeconds * MaxReleaseRatePSIpS;
+                    CylPressurePSI = AutoCylPressurePSI;
+                    Car.WheelBrakeSlideProtectionTimerS -= elapsedClockSeconds;
+
+                    // Lockout WSP dump valve if it is open for greater then 7 seconds continuously
+                    if (Car.WheelBrakeSlideProtectionTimerS <= 0)
+                    {
+                        Car.WheelBrakeSlideProtectionDumpValveLockout = true;
+                    }
+
+                }
+                else if (!Car.WheelBrakeSlideProtectionDumpValveLockout)
+                {
+                    // WSP dump valve stops
+                    Car.WheelBrakeSlideProtectionActive = false;
+                    Car.WheelBrakeSlideProtectionTimerS = Car.wheelBrakeSlideTimerResetValueS; // Reset WSP timer if 
+                }
+
+            }
+                       
             // Record HUD display values for brake cylinders depending upon whether they are wagons or locomotives/tenders (which are subject to their own engine brakes)   
             if (Car.WagonType == MSTSWagon.WagonTypes.Engine || Car.WagonType == MSTSWagon.WagonTypes.Tender)
             {
@@ -569,6 +610,23 @@ public override void Update(float elapsedClockSeconds)
                 }
                 prevCylPressurePSI = AutoCylPressurePSI;
                 prevBrakePipePressurePSI = BrakeLine1PressurePSI;
+
+                var lead = Car as MSTSLocomotive;
+
+                if (lead != null && Car.WagonType == MSTSWagon.WagonTypes.Engine)
+                {
+                    if (lead.TrainBrakeController.TrainBrakeControllerState == ControllerState.Overcharge && !lead.BrakeOverchargeSoundOn)
+                    {
+                        Car.SignalEvent(Event.OverchargeBrakingOn);
+                        lead.BrakeOverchargeSoundOn = true;
+                    }
+                    else if (lead.TrainBrakeController.TrainBrakeControllerState != ControllerState.Overcharge && lead.BrakeOverchargeSoundOn)
+                    {
+                        Car.SignalEvent(Event.OverchargeBrakingOff);
+                        lead.BrakeOverchargeSoundOn = false;
+                    }
+                }
+
             }
             SoundTriggerCounter = SoundTriggerCounter + elapsedClockSeconds;
         }
@@ -740,7 +798,9 @@ protected static void PropagateBrakeLinePressures(float elapsedClockSeconds, Tra
             int last = -1;
             train.FindLeadLocomotives(ref first, ref last);
             float sumpv = 0;
+            float summainrespv = 0;
             float sumv = 0;
+            float summainresv = 0;
             int continuousFromInclusive = 0;
             int continuousToExclusive = train.Cars.Count;
             for (int i = 0; i < train.Cars.Count; i++)
@@ -767,11 +827,22 @@ protected static void PropagateBrakeLinePressures(float elapsedClockSeconds, Tra
                 {
                     sumv += brakeSystem.BrakePipeVolumeM3;
                     sumpv += brakeSystem.BrakePipeVolumeM3 * brakeSystem.BrakeLine2PressurePSI;
+
+                    summainresv += brakeSystem.BrakePipeVolumeM3;
+
+                    if (lead != null)
+                    {
+                        summainrespv += brakeSystem.BrakePipeVolumeM3 * lead.MainResPressurePSI;
+                    }
+
                     var eng = train.Cars[i] as MSTSLocomotive;
                     if (eng != null)
                     {
                         sumv += eng.MainResVolumeM3;
                         sumpv += eng.MainResVolumeM3 * eng.MainResPressurePSI;
+
+                        summainresv += eng.MainResVolumeM3;
+                        summainrespv += eng.MainResVolumeM3 * eng.MainResPressurePSI;
                     }
                 }
 
@@ -820,24 +891,39 @@ protected static void PropagateBrakeLinePressures(float elapsedClockSeconds, Tra
                 }
             }
             if (sumv > 0)
+            {
                 sumpv /= sumv;
+                summainrespv /= summainresv;
+            }
 
             if (!train.Cars[continuousFromInclusive].BrakeSystem.FrontBrakeHoseConnected && train.Cars[continuousFromInclusive].BrakeSystem.AngleCockAOpen
                 || (continuousToExclusive == train.Cars.Count || !train.Cars[continuousToExclusive].BrakeSystem.FrontBrakeHoseConnected) && train.Cars[continuousToExclusive - 1].BrakeSystem.AngleCockBOpen)
+            {
                 sumpv = 0;
+                summainrespv = 0;
+            }
 
             // Propagate main reservoir pipe (2) data
             train.BrakeLine2PressurePSI = sumpv;
             for (int i = 0; i < train.Cars.Count; i++)
             {
                 if (first <= i && i <= last || twoPipes && continuousFromInclusive <= i && i < continuousToExclusive)
                 {
+
+                    if (lead != null && sumpv > lead.MaximumMainReservoirPipePressurePSI)
+                    {
+                        sumpv = lead.MaximumMainReservoirPipePressurePSI;
+                    }
+
                     train.Cars[i].BrakeSystem.BrakeLine2PressurePSI = sumpv;
                     if (sumpv != 0 && train.Cars[i] is MSTSLocomotive)
-                        (train.Cars[i] as MSTSLocomotive).MainResPressurePSI = sumpv;
+                        (train.Cars[i] as MSTSLocomotive).MainResPressurePSI = summainrespv;
                 }
                 else
-                    train.Cars[i].BrakeSystem.BrakeLine2PressurePSI = train.Cars[i] is MSTSLocomotive ? (train.Cars[i] as MSTSLocomotive).MainResPressurePSI : 0;
+                {
+                    // train.Cars[i].BrakeSystem.BrakeLine2PressurePSI = train.Cars[i] is MSTSLocomotive ? (train.Cars[i] as MSTSLocomotive).MainResPressurePSI : 0;
+                    train.Cars[i].BrakeSystem.BrakeLine2PressurePSI = train.Cars[i] is MSTSLocomotive ? (train.Cars[i] as MSTSLocomotive).MaximumMainReservoirPipePressurePSI : 0;
+                }
             }
         }