protected void UpdateTVM()
{
if (TVM300Present && IsSpeedControlEnabled())
{
// Automatic arming
if (NextPostSpeedLimitMpS(0) > MpS.FromKpH(221f) && NextPostDistanceM(0) < 5f && PreviousLineSpeed <= MpS.FromKpH(221f) && SpeedMpS() > 0f && !TVMArmed)
{
TVMArmed = true;
UpdateTVMAspect(NextSignalAspect(0), false);
}
// Automatic dearming
if (CurrentPostSpeedLimitMpS() <= MpS.FromKpH(221f) && PreviousLineSpeed > MpS.FromKpH(221f) && SpeedMpS() > 0f && TVMArmed)
{
TVMArmed = false;
}
if (TVMArmed)
{
// TVM mask
SetCabDisplayControl(TVM_Mask, 1);
UpdateTVM300Display();
UpdateTVM300COVIT();
}
else
{
// TVM mask
SetCabDisplayControl(TVM_Mask, 0);
TVMAspect = Aspect.None;
TVMPreviousAspect = Aspect.None;
}
}
}
int LEDSpeed = -1; // speed in tenths displayed on RailDriver LED
/// <summary>
/// Updates speed display on RailDriver LED
/// </summary>
/// <param name="playerLoco"></param>
public void Update(TrainCar playerLoco)
{
if (!Active || playerLoco == null || Device == null)
{
return;
}
float speed = 10 * MpS.FromMpS(playerLoco.SpeedMpS, false);
int s = (int)(speed >= 0 ? speed + .5 : -speed + .5);
if (s != LEDSpeed)
{
if (s < 100)
{
SetLEDs(LEDDigits[s % 10], LEDDigitsPoint[s / 10], 0);
}
else if (s < 1000)
{
SetLEDs(LEDDigits[s % 10], LEDDigitsPoint[(s / 10) % 10], LEDDigits[(s / 100) % 10]);
}
else if (s < 10000)
{
SetLEDs(LEDDigitsPoint[(s / 10) % 10], LEDDigits[(s / 100) % 10], LEDDigits[(s / 1000) % 10]);
}
LEDSpeed = s;
}
}
protected void UpdateTVM300COVIT()
{
if (TVMCOVITInhibited)
{
TVMCOVITEmergencyBraking = false;
}
else
{
TVM300CurrentSpeedLimitMpS = MpS.FromKpH(TVM300CurrentSpeedLimitsKph[NextSignalAspect(0)]);
TVM300NextSpeedLimitMpS = MpS.FromKpH(TVM300NextSpeedLimitsKph[NextSignalAspect(0)]);
SetNextSpeedLimitMpS(TVM300NextSpeedLimitMpS);
SetCurrentSpeedLimitMpS(TVM300CurrentSpeedLimitMpS);
TVM300EmergencySpeedMpS = TVM300GetEmergencySpeed(TVM300CurrentSpeedLimitMpS);
if (!TVMCOVITEmergencyBraking && SpeedMpS() > TVM300CurrentSpeedLimitMpS + TVM300EmergencySpeedMpS)
{
TVMCOVITEmergencyBraking = true;
}
if (TVMCOVITEmergencyBraking && SpeedMpS() <= TVM300CurrentSpeedLimitMpS)
{
TVMCOVITEmergencyBraking = false;
}
}
}
protected void UpdateTVM430COVIT()
{
if (TVM430TrainSpeedLimitMpS == MpS.FromKpH(320f))
{
TVM430CurrentSpeedLimitMpS = MpS.FromKpH(TVM430S320CurrentSpeedLimitsKph[NextSignalAspect(0)]);
TVM430NextSpeedLimitMpS = MpS.FromKpH(TVM430S320NextSpeedLimitsKph[NextSignalAspect(0)]);
}
else
{
TVM430CurrentSpeedLimitMpS = MpS.FromKpH(TVM430S300CurrentSpeedLimitsKph[NextSignalAspect(0)]);
TVM430NextSpeedLimitMpS = MpS.FromKpH(TVM430S300NextSpeedLimitsKph[NextSignalAspect(0)]);
}
SetNextSpeedLimitMpS(TVM430NextSpeedLimitMpS);
SetCurrentSpeedLimitMpS(TVM430CurrentSpeedLimitMpS);
TVM430CurrentEmergencySpeedMpS = TVM430GetEmergencySpeed(TVM430CurrentSpeedLimitMpS);
TVM430NextEmergencySpeedMpS = TVM430GetEmergencySpeed(TVM430NextSpeedLimitMpS);
if (SignalPassed)
{
TVM430EmergencyDecelerationMpS2 = Deceleration(
TVM430CurrentSpeedLimitMpS + TVM430CurrentEmergencySpeedMpS,
TVM430NextSpeedLimitMpS + TVM430NextEmergencySpeedMpS,
NextSignalDistanceM(0)
);
TVM430ResetDecelerationMpS2 = Deceleration(
TVM430CurrentSpeedLimitMpS,
TVM430NextSpeedLimitMpS,
NextSignalDistanceM(0)
);
}
TVM430EmergencySpeedCurveMpS = SpeedCurve(
NextSignalDistanceM(0),
TVM430NextSpeedLimitMpS + TVM430NextEmergencySpeedMpS,
0,
0,
TVM430EmergencyDecelerationMpS2
);
TVM430ResetSpeedCurveMpS = SpeedCurve(
NextSignalDistanceM(0),
TVM430NextSpeedLimitMpS,
0,
0,
TVM430ResetDecelerationMpS2
);
if (!TVMCOVITEmergencyBraking && SpeedMpS() > TVM430EmergencySpeedCurveMpS)
{
TVMCOVITEmergencyBraking = true;
}
if (TVMCOVITEmergencyBraking && SpeedMpS() <= TVM430ResetSpeedCurveMpS)
{
TVMCOVITEmergencyBraking = false;
}
}
public static void InverseRelations()
{
Assert.Equal(1.2f, Me.FromMi(Me.ToMi(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Me.FromKiloM(Me.ToKiloM(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Me.FromYd(Me.ToYd(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Me.FromFt(Me.ToFt(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Me.FromIn(Me.ToIn(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Me2.FromFt2(Me2.ToFt2(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Me2.FromIn2(Me2.ToIn2(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Me3.FromFt3(Me3.ToFt3(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Me3.FromIn3(Me3.ToIn3(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, MpS.FromMpH(MpS.ToMpH(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, MpS.FromKpH(MpS.ToKpH(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Kg.FromLb(Kg.ToLb(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Kg.FromTUS(Kg.ToTUS(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Kg.FromTUK(Kg.ToTUK(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Kg.FromTonne(Kg.ToTonne(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, N.FromLbf(N.ToLbf(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, KgpS.FromLbpH(KgpS.ToLbpH(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, W.FromKW(W.ToKW(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, W.FromHp(W.ToHp(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, W.FromBTUpS(W.ToBTUpS(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, KPa.FromPSI(KPa.ToPSI(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, KPa.FromInHg(KPa.ToInHg(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, KPa.FromBar(KPa.ToBar(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, KPa.FromKgfpCm2(KPa.ToKgfpCm2(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Bar.FromKPa(Bar.ToKPa(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Bar.FromPSI(Bar.ToPSI(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Bar.FromInHg(Bar.ToInHg(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, Bar.FromKgfpCm2(Bar.ToKgfpCm2(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, BarpS.FromPSIpS(BarpS.ToPSIpS(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, KJpKg.FromBTUpLb(KJpKg.ToBTUpLb(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, L.FromGUK(L.ToGUK(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, L.FromGUS(L.ToGUS(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, pS.FrompM(pS.TopM(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, pS.FrompH(pS.TopH(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, S.FromM(S.ToM(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, S.FromH(S.ToH(1.2f)), RequestedAccuracy);
Assert.Equal(1.2f, C.FromF(C.ToF(1.2f)), RequestedAccuracy);
Assert.Equal(12f, C.FromK(C.ToK(12f)), RequestedAccuracy); // we loose accuracy because of the large 273.15
}
void RecordSteamPerformance()
{
MSTSSteamLocomotive steamloco = (MSTSSteamLocomotive)Viewer.PlayerLocomotive;
float SteamspeedMpH = MpS.ToMpH(steamloco.SpeedMpS);
if (SteamspeedMpH >= previousLoggedSteamSpeedMpH + 5) // Add a new record every time speed increases by 5 mph
{
previousLoggedSteamSpeedMpH = (float)(int)SteamspeedMpH; // Keep speed records close to whole numbers
Logger.Data(MpS.FromMpS(Viewer.PlayerLocomotive.SpeedMpS, false).ToString("F0"));
Logger.Data(S.ToM(steamloco.SteamPerformanceTimeS).ToString("F1"));
Logger.Data(Viewer.PlayerLocomotive.ThrottlePercent.ToString("F0"));
Logger.Data(Viewer.PlayerTrain.MUReverserPercent.ToString("F0"));
Logger.Data(N.ToLbf(Viewer.PlayerLocomotive.MotiveForceN).ToString("F0"));
Logger.Data(steamloco.IndicatedHorsePowerHP.ToString("F0"));
Logger.Data(steamloco.DrawBarPullLbsF.ToString("F0"));
Logger.Data(steamloco.DrawbarHorsePowerHP.ToString("F0"));
Logger.Data(N.ToLbf(steamloco.LocomotiveCouplerForceN).ToString("F0"));
Logger.Data(N.ToLbf(steamloco.LocoTenderFrictionForceN).ToString("F0"));
Logger.Data(N.ToLbf(steamloco.TotalFrictionForceN).ToString("F0"));
Logger.Data(Kg.ToTUK(steamloco.TrainLoadKg).ToString("F0"));
Logger.Data(steamloco.BoilerPressurePSI.ToString("F0"));
Logger.Data(steamloco.LogSteamChestPressurePSI.ToString("F0"));
Logger.Data(steamloco.LogInitialPressurePSI.ToString("F0"));
Logger.Data(steamloco.LogCutoffPressurePSI.ToString("F0"));
Logger.Data(steamloco.LogReleasePressurePSI.ToString("F0"));
Logger.Data(steamloco.LogBackPressurePSI.ToString("F0"));
Logger.Data(steamloco.MeanEffectivePressurePSI.ToString("F0"));
Logger.Data(steamloco.CurrentSuperheatTempF.ToString("F0"));
Logger.Data(pS.TopH(steamloco.CylinderSteamUsageLBpS).ToString("F0"));
Logger.Data(pS.TopH(steamloco.WaterConsumptionLbpS).ToString("F0"));
Logger.Data(Kg.ToLb(pS.TopH(steamloco.FuelBurnRateSmoothedKGpS)).ToString("F0"));
Logger.Data(steamloco.SuperheaterSteamUsageFactor.ToString("F2"));
Logger.Data(steamloco.CumulativeCylinderSteamConsumptionLbs.ToString("F0"));
Logger.Data(steamloco.CumulativeWaterConsumptionLbs.ToString("F0"));
Logger.Data(steamloco.CutoffPressureDropRatio.ToString("F2"));
Logger.Data(steamloco.HPCylinderMEPPSI.ToString("F0"));
Logger.Data(steamloco.LogLPInitialPressurePSI.ToString("F0"));
Logger.Data(steamloco.LogLPCutoffPressurePSI.ToString("F0"));
Logger.Data(steamloco.LogLPReleasePressurePSI.ToString("F0"));
Logger.Data(steamloco.LogLPBackPressurePSI.ToString("F0"));
Logger.Data(steamloco.CutoffPressureDropRatio.ToString("F2"));
Logger.Data(steamloco.LPCylinderMEPPSI.ToString("F0"));
Logger.End();
}
}
public override void Initialize()
{
// General section
VACMAPresent = GetBoolParameter("General", "VACMAPresent", true);
RSPresent = GetBoolParameter("General", "RSPresent", true);
DAATPresent = GetBoolParameter("General", "DAATPresent", false);
TVM300Present = GetBoolParameter("General", "TVM300Present", false);
// RS section
RSDelayBeforeEmergencyBrakingS = GetFloatParameter("RS", "DelayBeforeEmergencyBrakingS", 4f);
RSBlinkerFrequencyHz = GetFloatParameter("RS", "BlinkerFrequencyHz", 1f);
// TVM common section
TVMCOVITInhibited = GetBoolParameter("TVM", "CovitInhibited", false);
// TVM300 section
TVM300TrainSpeedLimitMpS = MpS.FromKpH(GetFloatParameter("TVM300", "TrainSpeedLimitKpH", 300f));
// VACMA section
VACMAActivationSpeedMpS = MpS.FromKpH(GetFloatParameter("VACMA", "ActivationSpeedKpH", 3f));
VACMAReleasedAlertDelayS = GetFloatParameter("VACMA", "ReleasedAlertDelayS", 2.5f);
VACMAReleasedEmergencyDelayS = GetFloatParameter("VACMA", "ReleasedEmergencyDelayS", 5f);
VACMAPressedAlertDelayS = GetFloatParameter("VACMA", "PressedAlertDelayS", 55f);
VACMAPressedEmergencyDelayS = GetFloatParameter("VACMA", "PressedEmergencyDelayS", 60f);
// Variables initialization
RSBlinker = new Blinker(this);
RSBlinker.Setup(RSBlinkerFrequencyHz);
RSBlinker.Start();
RSEmergencyTimer = new Timer(this);
RSEmergencyTimer.Setup(RSDelayBeforeEmergencyBrakingS);
VACMAPressedAlertTimer = new Timer(this);
VACMAPressedAlertTimer.Setup(VACMAPressedAlertDelayS);
VACMAPressedEmergencyTimer = new Timer(this);
VACMAPressedEmergencyTimer.Setup(VACMAPressedEmergencyDelayS);
VACMAReleasedAlertTimer = new Timer(this);
VACMAReleasedAlertTimer.Setup(VACMAReleasedAlertDelayS);
VACMAReleasedEmergencyTimer = new Timer(this);
VACMAReleasedEmergencyTimer.Setup(VACMAReleasedEmergencyDelayS);
// Cabview control names initialization
SetCustomizedCabviewControlName(BP_AC_SF, "BP (AC) SF : Acquittement / Acknowledge");
SetCustomizedCabviewControlName(BP_A_LS_SF, "BP (A) LS (SF) : Annulation LS (SF) / Cancel LS (SF)");
SetCustomizedCabviewControlName(Z_ES_VA, "Z (ES) VA : Essai VACMA / Alerter test");
SetCustomizedCabviewControlName(BP_AM_V1, "BP AM V1 : Armement manuel TVM voie 1 / TVM manual arming track 1");
SetCustomizedCabviewControlName(BP_AM_V2, "BP AM V2 : Armement manuel TVM voie 2 / TVM manual arming track 2");
SetCustomizedCabviewControlName(BP_DM, "BP DM : Désarmement manuel TVM / TVM manual dearming");
SetCustomizedCabviewControlName(LS_SF, "LS (SF) : Signal Fermé / Closed Signal");
SetCustomizedCabviewControlName(TVM_Mask, "Masque TVM / TVM mask");
Activated = true;
SetNextSignalAspect(Aspect.Clear_1);
}
void CreateTargetSpeeds(List <PlanningTarget> speedTargets)
{
var speedTargetText = new List <TextPrimitive>(speedTargets.Count);
var speedTargetTextures = new List <LocatedTexture>(speedTargets.Count);
int ld = 0;
for (int i = 1; i < speedTargets.Count; i++)
{
bool overlap = false;
for (int j = 1; j < speedTargets.Count; j++)
{
if (i != j && CheckTargetOverlap(speedTargets[i], speedTargets[j]))
{
overlap = true;
break;
}
}
if (overlap)
{
continue;
}
PlanningTarget cur = speedTargets[i];
PlanningTarget prev = speedTargets[ld];
if (cur.DistanceToTrainM < 0)
{
continue;
}
ld = i;
bool im = cur.Equals(IndicationMarkerTarget);
if (cur.DistanceToTrainM > MaxViewingDistanceM)
{
break;
}
int a = GetPlanningHeight(cur.DistanceToTrainM) - 15;
string text = ((int)MpS.ToKpH(cur.TargetSpeedMpS)).ToString();
if (im || prev.TargetSpeedMpS > cur.TargetSpeedMpS || cur.TargetSpeedMpS == 0)
{
speedTargetText.Add(new TextPrimitive(new Point(25, a - 2), im ? ColorYellow : ColorGrey, text, FontTargetSpeed));
speedTargetTextures.Add(new LocatedTexture(im ? YellowSpeedReductionTexture : SpeedReductionTexture, 4, a + 7 - 10));
}
else
{
speedTargetText.Add(new TextPrimitive(new Point(25, a - 2 - (int)FontHeightTargetSpeed), ColorGrey, text, FontTargetSpeed));
speedTargetTextures.Add(new LocatedTexture(SpeedIncreaseTexture, 4, a - 7 - 10));
}
if (cur.TargetSpeedMpS == 0)
{
break;
}
}
SpeedTargetText = speedTargetText;
SpeedTargetTextures = speedTargetTextures;
}
public override void InitializeMoving()
{
RSState = RSStateType.Off;
RSEmergencyBraking = false;
VACMAEmergencyBraking = false;
if (CurrentPostSpeedLimitMpS() > MpS.FromKpH(221f))
{
TVMArmed = true;
UpdateTVMAspect(NextSignalAspect(0), false);
}
}
public CircularSpeedGaugeControl(int width, int height, float maxSpeedMpS, WindowManager owner)
: base(0, 0, width, height)
{
CircularSpeedGauge = new CircularSpeedGauge(
width,
height,
owner.Viewer.MilepostUnitsMetric ? (int)MpS.ToKpH(maxSpeedMpS) : (int)MpS.ToMpH(maxSpeedMpS),
owner.Viewer.MilepostUnitsMetric,
true,
(int)MpS.ToKpH(maxSpeedMpS) == 240 || (int)MpS.ToKpH(maxSpeedMpS) == 260,
0,
(MSTSLocomotive)owner.Viewer.PlayerLocomotive,
owner.Viewer
);
}
void RecordSteamPowerCurve()
{
MSTSSteamLocomotive loco = (MSTSSteamLocomotive)Viewer.PlayerLocomotive;
float speedMpH = MpS.ToMpH(loco.SpeedMpS);
if (speedMpH >= previousLoggedSpeedMpH + 1) // Add a new record every time speed increases by 1 mph
{
previousLoggedSpeedMpH = (float)(int)speedMpH; // Keep speed records close to whole numbers
Logger.Data(speedMpH.ToString("F1"));
float power = W.ToHp(loco.MotiveForceN * loco.SpeedMpS);
Logger.Data(power.ToString("F1"));
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).ThrottlePercent.ToString("F0"));
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).Train.MUReverserPercent.ToString("F0"));
Logger.End();
}
}
private float TVM300GetEmergencySpeed(float speedLimit)
{
float emergencySpeed = 0f;
if (speedLimit <= MpS.FromKpH(80f))
{
emergencySpeed = MpS.FromKpH(5f);
}
else if (speedLimit <= MpS.FromKpH(160f))
{
emergencySpeed = MpS.FromKpH(10f);
}
else
{
emergencySpeed = MpS.FromKpH(15f);
}
return(emergencySpeed);
}
public static void MultiUnitConversions()
{
Assert.Equal(1.2f, MpS.FromMpS(MpS.FromKpH(1.2f), true), RequestedAccuracy);
Assert.Equal(1.2f, MpS.FromMpS(MpS.FromMpH(1.2f), false), RequestedAccuracy);
Assert.Equal(1.2f, MpS.ToMpS(MpS.ToKpH(1.2f), true), RequestedAccuracy);
Assert.Equal(1.2f, MpS.ToMpS(MpS.ToMpH(1.2f), false), RequestedAccuracy);
Assert.Equal(1.2f, KPa.FromKPa(1.2f, PressureUnit.KPa), RequestedAccuracy);
Assert.Equal(1.2f, KPa.FromBar(KPa.FromKPa(1.2f, PressureUnit.Bar)), RequestedAccuracy);
Assert.Equal(1.2f, KPa.FromInHg(KPa.FromKPa(1.2f, PressureUnit.InHg)), RequestedAccuracy);
Assert.Equal(1.2f, KPa.FromKgfpCm2(KPa.FromKPa(1.2f, PressureUnit.KgfpCm2)), RequestedAccuracy);
Assert.Equal(1.2f, KPa.FromPSI(KPa.FromKPa(1.2f, PressureUnit.PSI)), RequestedAccuracy);
Assert.Throws <ArgumentOutOfRangeException>(() => KPa.FromKPa(1.2f, PressureUnit.None));
Assert.Equal(1.2f, KPa.ToKPa(1.2f, PressureUnit.KPa), RequestedAccuracy);
Assert.Equal(1.2f, KPa.ToBar(KPa.ToKPa(1.2f, PressureUnit.Bar)), RequestedAccuracy);
Assert.Equal(1.2f, KPa.ToInHg(KPa.ToKPa(1.2f, PressureUnit.InHg)), RequestedAccuracy);
Assert.Equal(1.2f, KPa.ToKgfpCm2(KPa.ToKPa(1.2f, PressureUnit.KgfpCm2)), RequestedAccuracy);
Assert.Equal(1.2f, KPa.ToPSI(KPa.ToKPa(1.2f, PressureUnit.PSI)), RequestedAccuracy);
Assert.Throws <ArgumentOutOfRangeException>(() => KPa.ToKPa(1.2f, PressureUnit.None));
}
/// <summary>
/// Default constructor used during file parsing.
/// </summary>
/// <param name="stf">The STFreader containing the file stream</param>
public SignalAspect(STFReader stf)
{
SpeedMpS = -1;
stf.MustMatch("(");
string aspectName = stf.ReadString();
try
{
Aspect = (MstsSignalAspect)Enum.Parse(typeof(MstsSignalAspect), aspectName, true);
}
catch (ArgumentException)
{
STFException.TraceInformation(stf, "Skipped unknown signal aspect " + aspectName);
Aspect = MstsSignalAspect.UNKNOWN;
}
DrawStateName = stf.ReadString().ToLowerInvariant();
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("speedmph", () => { SpeedMpS = MpS.FromMpH(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("speedkph", () => { SpeedMpS = MpS.FromKpH(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("signalflags", () => {
stf.MustMatch("(");
while (!stf.EndOfBlock())
{
switch (stf.ReadString().ToLower())
{
case "asap": Asap = true; break;
case "or_speedreset": Reset = true; break;
case "or_nospeedreduction": NoSpeedReduction = true; break;
default: stf.StepBackOneItem(); STFException.TraceInformation(stf, "Skipped unknown DrawLight flag " + stf.ReadString()); break;
}
}
}),
});
}
public override void Initialize()
{
// General section
VACMAPresent = GetBoolParameter("General", "VACMAPresent", true);
RSOPresent = GetBoolParameter("General", "RSOPresent", true);
DAATPresent = GetBoolParameter("General", "DAATPresent", false);
KVBPresent = GetBoolParameter("General", "KVBPresent", false);
TVM300Present = GetBoolParameter("General", "TVM300Present", false);
TVM430Present = GetBoolParameter("General", "TVM430Present", false);
ETCSPresent = GetBoolParameter("General", "ETCSPresent", false);
ElectroPneumaticBrake = GetBoolParameter("General", "ElectroPneumaticBrake", false);
HeavyFreightTrain = GetBoolParameter("General", "HeavyFreightTrain", false);
SafeDecelerationMpS2 = GetFloatParameter("General", "SafeDecelerationMpS2", 0.7f);
// KVB section
KVBInhibited = GetBoolParameter("KVB", "Inhibited", false);
KVBTrainSpeedLimitMpS = MpS.FromKpH(GetFloatParameter("KVB", "TrainSpeedLimitKpH", 160f));
// TVM common section
TVMCOVITInhibited = GetBoolParameter("TVM", "CovitInhibited", false);
// TVM300 section
TVM300TrainSpeedLimitMpS = MpS.FromKpH(GetFloatParameter("TVM300", "TrainSpeedLimitKpH", 300f));
// TVM430 section
TVM430TrainSpeedLimitMpS = MpS.FromKpH(GetFloatParameter("TVM430", "TrainSpeedLimitKpH", 320f));
// VACMA section
VACMAActivationSpeedMpS = MpS.FromKpH(GetFloatParameter("VACMA", "ActivationSpeedKpH", 3f));
VACMAReleasedAlertDelayS = GetFloatParameter("VACMA", "ReleasedAlertDelayS", 2.5f);
VACMAReleasedEmergencyDelayS = GetFloatParameter("VACMA", "ReleasedEmergencyDelayS", 5f);
VACMAPressedAlertDelayS = GetFloatParameter("VACMA", "PressedAlertDelayS", 55f);
VACMAPressedEmergencyDelayS = GetFloatParameter("VACMA", "PressedEmergencyDelayS", 60f);
// Variables initialization
KVBCurrentSignalSpeedLimitMpS = KVBTrainSpeedLimitMpS;
KVBNextSignalSpeedLimitMpS = KVBTrainSpeedLimitMpS;
KVBSignalTargetSpeedMpS = KVBTrainSpeedLimitMpS;
KVBSignalTargetDistanceM = 0f;
KVBCurrentSpeedPostSpeedLimitMpS = KVBTrainSpeedLimitMpS;
KVBNextSpeedPostSpeedLimitMpS = KVBTrainSpeedLimitMpS;
KVBSpeedPostTargetSpeedMpS = KVBTrainSpeedLimitMpS;
KVBSpeedPostTargetDistanceM = 0f;
KVBCurrentAlertSpeedMpS = MpS.FromKpH(5f);
KVBCurrentEBSpeedMpS = MpS.FromKpH(10f);
KVBNextAlertSpeedMpS = MpS.FromKpH(5f);
KVBNextEBSpeedMpS = MpS.FromKpH(10f);
VACMAPressedAlertTimer = new Timer(this);
VACMAPressedAlertTimer.Setup(VACMAPressedAlertDelayS);
VACMAPressedEmergencyTimer = new Timer(this);
VACMAPressedEmergencyTimer.Setup(VACMAPressedEmergencyDelayS);
VACMAReleasedAlertTimer = new Timer(this);
VACMAReleasedAlertTimer.Setup(VACMAReleasedAlertDelayS);
VACMAReleasedEmergencyTimer = new Timer(this);
VACMAReleasedEmergencyTimer.Setup(VACMAReleasedEmergencyDelayS);
TVM430AspectChangeTimer = new Timer(this);
TVM430AspectChangeTimer.Setup(4.7f);
Activated = true;
PreviousSignalDistanceM = 0f;
}
public override float Update(float elapsedSeconds)
{
if (TCSEmergencyBraking())
{
allowConnect = true;
}
if (client == null && allowConnect)
{
TcpClient c = new TcpClient();
c.Connect("127.0.0.1", 5090);
client = new TCPClient(c);
client.WriteLine("register(train_brake)");
client.WriteLine("register(emergency_pushb)");
client.WriteLine("register(power)");
client.WriteLine("register(speed)");
}
if (client != null)
{
string line = client.ReadLine();
while (line != null)
{
string val = line.Substring(line.IndexOf('=') + 1);
if (line.StartsWith("train_brake="))
{
Value = float.Parse(val.Replace('.', ','));
}
else if (line.StartsWith("emergency_pushb="))
{
EBPB = val != "0" && val != "false";
}
else if (line.StartsWith("power="))
{
power = val == "1" || val == "true";
}
else if (line.StartsWith("speed="))
{
speed = MpS.FromKpH(float.Parse(val.Replace('.', ',')));
}
line = client.ReadLine();
}
}
if (UpdateValue() == 1)
{
if (Value > 0.9)
{
Value = 1;
SetUpdateValue(0);
}
else
{
float prev = Value;
Value += elapsedSeconds / 3;
if (Value >= 0.9 && prev < 0.9)
{
Value = 0.93f;
SetUpdateValue(0);
}
}
}
if (UpdateValue() == -1)
{
float prev = Value;
Value -= elapsedSeconds / 3;
if (Value <= 0)
{
Value = 0;
SetUpdateValue(0);
}
}
if (speed < 6 || !power)
{
dynavail = false;
}
else if (Value == 0)
{
dynavail = true;
}
if (EBPB || EmergencyBrakingPushButton() || TCSEmergencyBraking() || Value > 0.95f)
{
CurrentState = State.Emergency;
}
else if (TCSFullServiceBraking() || Value > 0.90f)
{
CurrentState = State.FullBrake;
}
else if (Value > 0.01)
{
CurrentState = State.Apply;
}
else
{
CurrentState = State.Release;
}
if (Value < 0.01)
{
applyValue = 0;
}
else
{
applyValue = Math.Min(Math.Max((Value - 0.01f) / 0.89f * 0.85f + 0.15f, 0.15f), 1);
}
float MaxDynForce = DynamicBrakeForce(speed);
float TargetForce = applyValue;
float TargetDynamicForce = CurrentState == State.Emergency ? 0 : Math.Min(TargetForce, MaxDynForce);
float TargetAirForce = TargetForce - TargetDynamicForce;
dynamicBrakeValue = MaxDynForce == 0 ? 0 : TargetDynamicForce / MaxDynForce;
airBrakeValue = Math.Max(TargetAirForce, 0);
if (client != null)
{
client.WriteLine("dynamic_brake=" + dynamicBrakeValue.ToString().Replace(',', '.'));
}
SetCurrentValue(Value);
return(CurrentValue());
}
public ApproachControlLimits(STFReader stf)
{
stf.ParseBlock(new STFReader.TokenProcessor[] {
new STFReader.TokenProcessor("positionmiles", () => { ApproachControlPositionM = Me.FromMi(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("positionkm", () => { ApproachControlPositionM = (stf.ReadFloatBlock(STFReader.UNITS.None, 0) * 1000); }),
new STFReader.TokenProcessor("positionm", () => { ApproachControlPositionM = stf.ReadFloatBlock(STFReader.UNITS.None, 0); }),
new STFReader.TokenProcessor("positionyd", () => { ApproachControlPositionM = Me.FromYd(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("speedmph", () => { ApproachControlSpeedMpS = MpS.FromMpH(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
new STFReader.TokenProcessor("speedkph", () => { ApproachControlSpeedMpS = MpS.FromKpH(stf.ReadFloatBlock(STFReader.UNITS.None, 0)); }),
});
}
protected void UpdateKVBSpeedCurve()
{
bool KVBOverspeed = false;
KVBSignalEmergencySpeedCurveMpS =
Math.Min(
Math.Min(
Math.Max(
SpeedCurve(
KVBSignalTargetDistanceM,
KVBSignalTargetSpeedMpS,
KVBDeclivity,
KVBDelayBeforeBrakingEstablishedS,
SafeDecelerationMpS2
),
KVBNextSignalSpeedLimitMpS + KVBNextEBSpeedMpS
),
KVBTrainSpeedLimitMpS + MpS.FromKpH(10f)
),
KVBCurrentSignalSpeedLimitMpS + KVBCurrentEBSpeedMpS
);
KVBSignalAlertSpeedCurveMpS =
Math.Min(
Math.Min(
Math.Max(
SpeedCurve(
KVBSignalTargetDistanceM,
KVBSignalTargetSpeedMpS,
KVBDeclivity,
KVBDelayBeforeBrakingEstablishedS + KVBDelayBeforeEmergencyBrakingS,
SafeDecelerationMpS2
),
KVBNextSignalSpeedLimitMpS + KVBNextAlertSpeedMpS
),
KVBTrainSpeedLimitMpS + MpS.FromKpH(5f)
),
KVBCurrentSignalSpeedLimitMpS + KVBCurrentAlertSpeedMpS
);
KVBSpeedPostEmergencySpeedCurveMpS =
Math.Min(
Math.Min(
Math.Max(
SpeedCurve(
KVBSpeedPostTargetDistanceM,
KVBSpeedPostTargetSpeedMpS,
KVBDeclivity,
KVBDelayBeforeBrakingEstablishedS,
SafeDecelerationMpS2
),
KVBNextSpeedPostSpeedLimitMpS + MpS.FromKpH(10f)
),
KVBTrainSpeedLimitMpS + MpS.FromKpH(10f)
),
KVBCurrentSpeedPostSpeedLimitMpS + MpS.FromKpH(10f)
);
KVBSpeedPostAlertSpeedCurveMpS =
Math.Min(
Math.Min(
Math.Max(
SpeedCurve(
KVBSpeedPostTargetDistanceM,
KVBSpeedPostTargetSpeedMpS,
KVBDeclivity,
KVBDelayBeforeBrakingEstablishedS + KVBDelayBeforeEmergencyBrakingS,
SafeDecelerationMpS2
),
KVBNextSpeedPostSpeedLimitMpS + MpS.FromKpH(5f)
),
KVBTrainSpeedLimitMpS + MpS.FromKpH(5f)
),
KVBCurrentSpeedPostSpeedLimitMpS + MpS.FromKpH(5f)
);
if (SpeedMpS() > KVBSignalAlertSpeedCurveMpS)
{
KVBOverspeed = true;
if (SpeedMpS() > KVBSignalEmergencySpeedCurveMpS)
{
KVBEmergencyBraking = true;
}
}
if (SpeedMpS() > KVBSpeedPostAlertSpeedCurveMpS)
{
KVBOverspeed = true;
if (SpeedMpS() > KVBSpeedPostEmergencySpeedCurveMpS)
{
KVBEmergencyBraking = true;
}
}
if (KVBEmergencyBraking && SpeedMpS() < 0.1f)
{
KVBEmergencyBraking = false;
}
SetOverspeedWarningDisplay(KVBOverspeed);
if (KVBOverspeed && !KVBPreviousOverspeed)
{
TriggerSoundPenalty1();
}
KVBPreviousOverspeed = KVBOverspeed;
if (KVBEmergencyBraking && !KVBPreviousEmergencyBraking)
{
TriggerSoundPenalty2();
}
KVBPreviousEmergencyBraking = KVBEmergencyBraking;
}
protected void UpdateKVB()
{
KVBTrainLengthM = (float)Math.Ceiling((double)(TrainLengthM() / 100f)) * 100f;
if (ElectroPneumaticBrake)
{
KVBDelayBeforeBrakingEstablishedS = 2f;
}
else if (HeavyFreightTrain)
{
KVBDelayBeforeBrakingEstablishedS = 12f + KVBTrainLengthM / 200f;
}
else
{
KVBDelayBeforeBrakingEstablishedS = 2f + 2f * KVBTrainLengthM * KVBTrainLengthM * 0.00001f;
}
// Decode signal aspect
switch (NextSignalAspect(0))
{
case Aspect.Stop:
KVBSignalTargetDistanceM = NextSignalDistanceM(0);
if (SignalPassed)
{
KVBNextSignalSpeedLimitMpS = MpS.FromKpH(10f);
KVBSignalTargetSpeedMpS = 0f;
KVBNextAlertSpeedMpS = MpS.FromKpH(2.5f);
KVBNextEBSpeedMpS = MpS.FromKpH(5f);
}
break;
case Aspect.StopAndProceed:
KVBSignalTargetDistanceM = NextSignalDistanceM(0);
if (SignalPassed)
{
KVBNextSignalSpeedLimitMpS = MpS.FromKpH(30f);
KVBSignalTargetSpeedMpS = 0f;
KVBNextAlertSpeedMpS = MpS.FromKpH(5f);
KVBNextEBSpeedMpS = MpS.FromKpH(10f);
}
break;
// Approach : Check if the 2nd signal is red (a yellow blinking aspect may have been crossed)
case Aspect.Approach_1:
case Aspect.Approach_2:
case Aspect.Approach_3:
switch (NextSignalAspect(1))
{
case Aspect.Stop:
KVBSignalTargetDistanceM = NextSignalDistanceM(1);
if (SignalPassed)
{
if (NextSignalSpeedLimitMpS(0) > 0f && NextSignalSpeedLimitMpS(0) < KVBTrainSpeedLimitMpS)
{
KVBNextSignalSpeedLimitMpS = NextSignalSpeedLimitMpS(0);
}
else
{
KVBNextSignalSpeedLimitMpS = KVBTrainSpeedLimitMpS;
}
KVBSignalTargetSpeedMpS = 0f;
KVBNextAlertSpeedMpS = MpS.FromKpH(2.5f);
KVBNextEBSpeedMpS = MpS.FromKpH(5f);
}
break;
case Aspect.StopAndProceed:
KVBSignalTargetDistanceM = NextSignalDistanceM(1);
if (SignalPassed)
{
if (NextSignalSpeedLimitMpS(0) > 0f && NextSignalSpeedLimitMpS(0) < KVBTrainSpeedLimitMpS)
{
KVBNextSignalSpeedLimitMpS = NextSignalSpeedLimitMpS(0);
}
else
{
KVBNextSignalSpeedLimitMpS = KVBTrainSpeedLimitMpS;
}
KVBSignalTargetSpeedMpS = 0f;
KVBNextAlertSpeedMpS = MpS.FromKpH(5f);
KVBNextEBSpeedMpS = MpS.FromKpH(10f);
}
break;
default:
KVBSignalTargetDistanceM = NextSignalDistanceM(0);
if (SignalPassed)
{
if (NextSignalSpeedLimitMpS(0) > 0f && NextSignalSpeedLimitMpS(0) < KVBTrainSpeedLimitMpS)
{
KVBNextSignalSpeedLimitMpS = NextSignalSpeedLimitMpS(0);
}
else
{
KVBNextSignalSpeedLimitMpS = KVBTrainSpeedLimitMpS;
}
KVBSignalTargetSpeedMpS = KVBNextSignalSpeedLimitMpS;
KVBNextAlertSpeedMpS = MpS.FromKpH(5f);
KVBNextEBSpeedMpS = MpS.FromKpH(10f);
}
break;
}
break;
// Clear
default:
KVBSignalTargetDistanceM = NextSignalDistanceM(0);
if (SignalPassed)
{
if (NextSignalSpeedLimitMpS(0) > 0f && NextSignalSpeedLimitMpS(0) < KVBTrainSpeedLimitMpS)
{
KVBNextSignalSpeedLimitMpS = NextSignalSpeedLimitMpS(0);
}
else
{
KVBNextSignalSpeedLimitMpS = KVBTrainSpeedLimitMpS;
}
KVBSignalTargetSpeedMpS = KVBNextSignalSpeedLimitMpS;
KVBNextAlertSpeedMpS = MpS.FromKpH(5f);
KVBNextEBSpeedMpS = MpS.FromKpH(10f);
}
break;
}
// Update current speed limit when speed is below the target or when the train approaches the signal
if (NextSignalDistanceM(0) <= 5f)
{
if (NextSignalSpeedLimitMpS(0) > 0f && NextSignalSpeedLimitMpS(0) < KVBTrainSpeedLimitMpS)
{
KVBCurrentSignalSpeedLimitMpS = NextSignalSpeedLimitMpS(0);
}
else
{
KVBCurrentSignalSpeedLimitMpS = KVBTrainSpeedLimitMpS;
}
}
// Speed post speed limit preparation
KVBNextSpeedPostSpeedLimitMpS = (NextPostSpeedLimitMpS(0) > 0 ? NextPostSpeedLimitMpS(0) : KVBTrainSpeedLimitMpS);
KVBCurrentSpeedPostSpeedLimitMpS = CurrentPostSpeedLimitMpS();
KVBSpeedPostTargetSpeedMpS = KVBNextSpeedPostSpeedLimitMpS;
KVBSpeedPostTargetDistanceM = NextPostDistanceM(0);
SetNextSpeedLimitMpS(Math.Min(KVBNextSignalSpeedLimitMpS, KVBNextSpeedPostSpeedLimitMpS));
SetCurrentSpeedLimitMpS(Math.Min(KVBCurrentSignalSpeedLimitMpS, KVBCurrentSpeedPostSpeedLimitMpS));
UpdateKVBSpeedCurve();
// Pre-announce aspect => KVB beep
if (KVBCurrentSpeedPostSpeedLimitMpS > MpS.FromKpH(160f))
{
if (KVBPreAnnounceActive)
{
if (
SignalPassed &&
KVBCurrentSignalSpeedLimitMpS > MpS.FromKpH(160f) &&
KVBNextSignalSpeedLimitMpS <= MpS.FromKpH(160f)
)
{
KVBPreAnnounceActive = false;
}
else if (
KVBNextSpeedPostSpeedLimitMpS <= MpS.FromKpH(160f) &&
KVBSpeedPostTargetDistanceM <= 3000f
)
{
KVBPreAnnounceActive = false;
}
}
else if (
SignalPassed &&
KVBCurrentSignalSpeedLimitMpS > MpS.FromKpH(160f) &&
KVBNextSignalSpeedLimitMpS > MpS.FromKpH(160f) &&
(
KVBNextSpeedPostSpeedLimitMpS > MpS.FromKpH(160f) ||
KVBSpeedPostTargetDistanceM > 3000f
)
)
{
KVBPreAnnounceActive = true;
}
}
else
{
KVBPreAnnounceActive = false;
}
if (!KVBPreAnnounceActive && KVBPreviousPreAnnounceActive)
{
TriggerSoundInfo2();
}
KVBPreviousPreAnnounceActive = KVBPreAnnounceActive;
}
protected void UpdateRSO()
{
if (NextSignalDistanceM(0) < 2f &&
(ActiveCCS == CCS.RSO || ActiveCCS == CCS.DAAT || ActiveCCS == CCS.KVB) &&
SpeedMpS() > 0)
{
if (NextSignalAspect(0) == Aspect.Stop ||
NextSignalAspect(0) == Aspect.StopAndProceed ||
NextSignalAspect(0) == Aspect.Restricted)
{
RSOClosedSignal = true;
}
else if (NextSignalAspect(1) == Aspect.Stop ||
NextSignalAspect(1) == Aspect.StopAndProceed)
{
RSOClosedSignal = true;
}
else if (NextSignalSpeedLimitMpS(1) >= 0f && NextSignalSpeedLimitMpS(1) < MpS.FromKpH(160f))
{
RSOClosedSignal = true;
}
else
{
RSOOpenedSignal = true;
}
}
if (SignalPassed)
{
RSOClosedSignal = RSOOpenedSignal = false;
}
if (RSOClosedSignal && !RSOPreviousClosedSignal && !RSOType1Inhibition)
{
TriggerSoundInfo1();
}
RSOPreviousClosedSignal = RSOClosedSignal;
if ((TVM300Present || TVM430Present) && TVMClosedSignal && !TVMPreviousClosedSignal)
{
TriggerSoundInfo1();
}
if ((TVM300Present || TVM430Present) && TVMOpenedSignal && !TVMPreviousOpenedSignal)
{
TriggerSoundInfo1();
}
TVMPreviousClosedSignal = TVMClosedSignal;
TVMPreviousOpenedSignal = TVMOpenedSignal;
}
public override void Update()
{
UpdateSignalPassed();
if (IsAlerterEnabled() && VACMAPresent)
{
UpdateVACMA();
}
if (IsTrainControlEnabled())
{
if (RSOPresent)
{
UpdateRSO();
}
if (CurrentPostSpeedLimitMpS() <= MpS.FromKpH(220f))
{
if (KVBPresent)
{
// Classic line = KVB active
ActiveCCS = CCS.KVB;
if (SignalPassed)
{
SetNextSignalAspect(NextSignalAspect(0));
}
UpdateKVB();
}
else
{
if (!DAATPresent)
{
ActiveCCS = CCS.RSO;
}
else
{
ActiveCCS = CCS.DAAT;
}
SetNextSignalAspect(Aspect.Clear_1);
}
}
else
{
// High speed line = TVM active
// Activation control (KAr) in KVB system
if (TVM300Present)
{
ActiveCCS = CCS.TVM300;
UpdateTVM300Display();
UpdateTVM300COVIT();
}
else if (TVM430Present)
{
ActiveCCS = CCS.TVM430;
UpdateTVM430Display();
UpdateTVM430COVIT();
}
else if (KVBPresent)
{
// TVM not activated because not present
ActiveCCS = CCS.KVB;
if (SignalPassed)
{
SetNextSignalAspect(NextSignalAspect(0));
}
KVBEmergencyBraking = true;
}
}
SetEmergencyBrake(
RSOEmergencyBraking ||
KVBEmergencyBraking ||
TVMCOVITEmergencyBraking ||
VACMAEmergencyBraking ||
ExternalEmergencyBraking
);
SetPenaltyApplicationDisplay(IsBrakeEmergency());
SetPowerAuthorization(!RSOEmergencyBraking &&
!KVBEmergencyBraking &&
!TVMCOVITEmergencyBraking &&
!VACMAEmergencyBraking
);
if (ActiveCCS != CCS.TVM300 && ActiveCCS != CCS.TVM430)
{
TVMAspect = Aspect.None;
TVMPreviousAspect = Aspect.None;
}
RSOType1Inhibition = IsDirectionReverse();
RSOType2Inhibition = !KVBInhibited && ((TVM300Present && ActiveCCS == CCS.TVM300) || (TVM430Present && ActiveCCS == CCS.TVM430));
RSOType3Inhibition = (TVM300Present || TVM430Present) && !TVMCOVITInhibited;
PreviousCCS = ActiveCCS;
}
}
void UpdateSpeedControl()
{
var interventionSpeedMpS = CurrentSpeedLimitMpS + MpS.FromKpH(5.0f); // Default margin : 5 km/h
if (OverspeedMonitor.TriggerOnTrackOverspeed)
{
interventionSpeedMpS = CurrentSpeedLimitMpS + OverspeedMonitor.TriggerOnTrackOverspeedMarginMpS;
}
SetInterventionSpeedLimitMpS(interventionSpeedMpS);
switch (OverspeedMonitorState)
{
case MonitorState.Disabled:
if (SpeedControlSystemEnabled)
{
OverspeedMonitorState = MonitorState.StandBy;
}
break;
case MonitorState.StandBy:
if (!SpeedControlSystemEnabled)
{
OverspeedMonitorState = MonitorState.Disabled;
}
else
{
if (Overspeed)
{
OverspeedMonitorState = MonitorState.Alarm;
}
}
break;
case MonitorState.Alarm:
if (!SpeedControlSystemEnabled)
{
OverspeedMonitorState = MonitorState.Disabled;
}
else
{
if (!OverspeedEmergencyTimer.Started)
{
OverspeedEmergencyTimer.Start();
}
if (!Overspeed)
{
OverspeedEmergencyTimer.Stop();
OverspeedMonitorState = MonitorState.StandBy;
}
else if (OverspeedEmergencyTimer.Triggered)
{
OverspeedEmergencyTimer.Stop();
OverspeedMonitorState = MonitorState.Emergency;
}
}
break;
case MonitorState.Emergency:
if (!OverspeedPenaltyTimer.Started)
{
OverspeedPenaltyTimer.Start();
}
if (OverspeedPenaltyTimer.Triggered && OverspeedReset)
{
OverspeedPenaltyTimer.Stop();
OverspeedMonitorState = MonitorState.StandBy;
}
break;
}
SetOverspeedWarningDisplay(OverspeedMonitorState >= MonitorState.Alarm);
}
public void PrepareFrame(RenderFrame frame, ElapsedTime elapsedTime)
{
FrameNumber++;
if (Viewer.RealTime - LastUpdateRealTime >= 0.25)
{
double elapsedRealSeconds = Viewer.RealTime - LastUpdateRealTime;
LastUpdateRealTime = Viewer.RealTime;
Profile(elapsedRealSeconds);
}
#if DEBUG_DUMP_STEAM_POWER_CURVE
if (IsRecordingSteamPowerCurve)
{
RecordSteamPowerCurve();
}
else
{
#endif
if (IsRecordingSteamPerformance)
{
RecordSteamPerformance();
}
else
//Here's where the logger stores the data from each frame
if (Viewer.Settings.DataLogger)
{
Logger.Separator = (DataLogger.Separators)Enum.Parse(typeof(DataLogger.Separators), Viewer.Settings.DataLoggerSeparator);
if (Viewer.Settings.DataLogPerformance)
{
Logger.Data(VersionInfo.Version);
Logger.Data(FrameNumber.ToString("F0"));
Logger.Data(GetWorkingSetSize().ToString("F0"));
Logger.Data(GC.GetTotalMemory(false).ToString("F0"));
Logger.Data(GC.CollectionCount(0).ToString("F0"));
Logger.Data(GC.CollectionCount(1).ToString("F0"));
Logger.Data(GC.CollectionCount(2).ToString("F0"));
Logger.Data(ProcessorCount.ToString("F0"));
Logger.Data(Viewer.RenderProcess.FrameRate.Value.ToString("F0"));
Logger.Data(Viewer.RenderProcess.FrameTime.Value.ToString("F6"));
Logger.Data(Viewer.RenderProcess.ShadowPrimitivePerFrame.Sum().ToString("F0"));
Logger.Data(Viewer.RenderProcess.PrimitivePerFrame.Sum().ToString("F0"));
Logger.Data(Viewer.RenderProcess.Profiler.Wall.Value.ToString("F0"));
Logger.Data(Viewer.UpdaterProcess.Profiler.Wall.Value.ToString("F0"));
Logger.Data(Viewer.LoaderProcess.Profiler.Wall.Value.ToString("F0"));
Logger.Data(Viewer.SoundProcess.Profiler.Wall.Value.ToString("F0"));
}
if (Viewer.Settings.DataLogPhysics)
{
Logger.Data(FormatStrings.FormatPreciseTime(Viewer.Simulator.ClockTime));
Logger.Data(Viewer.PlayerLocomotive.Direction.ToString());
Logger.Data(Viewer.PlayerTrain.MUReverserPercent.ToString("F0"));
Logger.Data(Viewer.PlayerLocomotive.ThrottlePercent.ToString("F0"));
Logger.Data(Viewer.PlayerLocomotive.MotiveForceN.ToString("F0"));
Logger.Data(Viewer.PlayerLocomotive.BrakeForceN.ToString("F0"));
Logger.Data((Viewer.PlayerLocomotive as MSTSLocomotive).LocomotiveAxle.AxleForceN.ToString("F2"));
Logger.Data((Viewer.PlayerLocomotive as MSTSLocomotive).LocomotiveAxle.SlipSpeedPercent.ToString("F1"));
switch (Viewer.Settings.DataLogSpeedUnits)
{
case "route":
Logger.Data(FormatStrings.FormatSpeed(Viewer.PlayerLocomotive.SpeedMpS, Viewer.MilepostUnitsMetric));
break;
case "mps":
Logger.Data(Viewer.PlayerLocomotive.SpeedMpS.ToString("F1"));
break;
case "mph":
Logger.Data(MpS.FromMpS(Viewer.PlayerLocomotive.SpeedMpS, false).ToString("F1"));
break;
case "kmph":
Logger.Data(MpS.FromMpS(Viewer.PlayerLocomotive.SpeedMpS, true).ToString("F1"));
break;
default:
Logger.Data(FormatStrings.FormatSpeed(Viewer.PlayerLocomotive.SpeedMpS, Viewer.MilepostUnitsMetric));
break;
}
Logger.Data((Viewer.PlayerLocomotive.DistanceM.ToString("F0")));
Logger.Data((Viewer.PlayerLocomotive.GravityForceN.ToString("F0")));
if ((Viewer.PlayerLocomotive as MSTSLocomotive).TrainBrakeController != null)
{
Logger.Data((Viewer.PlayerLocomotive as MSTSLocomotive).TrainBrakeController.CurrentValue.ToString("F2"));
}
else
{
Logger.Data("null");
}
if ((Viewer.PlayerLocomotive as MSTSLocomotive).EngineBrakeController != null)
{
Logger.Data((Viewer.PlayerLocomotive as MSTSLocomotive).EngineBrakeController.CurrentValue.ToString("F2"));
}
else
{
Logger.Data("null");
}
Logger.Data(Viewer.PlayerLocomotive.BrakeSystem.GetCylPressurePSI().ToString("F0"));
Logger.Data((Viewer.PlayerLocomotive as MSTSLocomotive).MainResPressurePSI.ToString("F0"));
Logger.Data((Viewer.PlayerLocomotive as MSTSLocomotive).CompressorIsOn.ToString());
#if GEARBOX_DEBUG_LOG
if (Viewer.PlayerLocomotive.GetType() == typeof(MSTSDieselLocomotive))
{
Logger.Data((Viewer.PlayerLocomotive as MSTSDieselLocomotive).DieselEngines[0].RealRPM.ToString("F0"));
Logger.Data((Viewer.PlayerLocomotive as MSTSDieselLocomotive).DieselEngines[0].DemandedRPM.ToString("F0"));
Logger.Data((Viewer.PlayerLocomotive as MSTSDieselLocomotive).DieselEngines[0].LoadPercent.ToString("F0"));
if ((Viewer.PlayerLocomotive as MSTSDieselLocomotive).DieselEngines.HasGearBox)
{
Logger.Data((Viewer.PlayerLocomotive as MSTSDieselLocomotive).DieselEngines[0].GearBox.CurrentGearIndex.ToString());
Logger.Data((Viewer.PlayerLocomotive as MSTSDieselLocomotive).DieselEngines[0].GearBox.NextGearIndex.ToString());
Logger.Data((Viewer.PlayerLocomotive as MSTSDieselLocomotive).DieselEngines[0].GearBox.ClutchPercent.ToString());
}
else
{
Logger.Data("null");
Logger.Data("null");
Logger.Data("null");
}
Logger.Data((Viewer.PlayerLocomotive as MSTSDieselLocomotive).DieselFlowLps.ToString("F2"));
Logger.Data((Viewer.PlayerLocomotive as MSTSDieselLocomotive).DieselLevelL.ToString("F0"));
Logger.Data("null");
Logger.Data("null");
Logger.Data("null");
}
if (Viewer.PlayerLocomotive.GetType() == typeof(MSTSElectricLocomotive))
{
Logger.Data((Viewer.PlayerLocomotive as MSTSElectricLocomotive).Pantographs[1].CommandUp.ToString());
Logger.Data((Viewer.PlayerLocomotive as MSTSElectricLocomotive).Pantographs[2].CommandUp.ToString());
Logger.Data((Viewer.PlayerLocomotive as MSTSElectricLocomotive).Pantographs.List.Count > 2 ?
(Viewer.PlayerLocomotive as MSTSElectricLocomotive).Pantographs[3].CommandUp.ToString() : null);
Logger.Data((Viewer.PlayerLocomotive as MSTSElectricLocomotive).Pantographs.List.Count > 3 ?
(Viewer.PlayerLocomotive as MSTSElectricLocomotive).Pantographs[4].CommandUp.ToString() : null);
Logger.Data("null");
Logger.Data("null");
Logger.Data("null");
Logger.Data("null");
Logger.Data("null");
Logger.Data("null");
Logger.Data("null");
}
if (Viewer.PlayerLocomotive.GetType() == typeof(MSTSSteamLocomotive))
{
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).BlowerSteamUsageLBpS.ToString("F0"));
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).BoilerPressurePSI.ToString("F0"));
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).CylinderCocksAreOpen.ToString());
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).CylinderCompoundOn.ToString());
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).EvaporationLBpS.ToString("F0"));
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).FireMassKG.ToString("F0"));
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).CylinderSteamUsageLBpS.ToString("F0"));
if ((Viewer.PlayerLocomotive as MSTSSteamLocomotive).BlowerController != null)
{
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).BlowerController.CurrentValue.ToString("F0"));
}
else
{
Logger.Data("null");
}
if ((Viewer.PlayerLocomotive as MSTSSteamLocomotive).DamperController != null)
{
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).DamperController.CurrentValue.ToString("F0"));
}
else
{
Logger.Data("null");
}
if ((Viewer.PlayerLocomotive as MSTSSteamLocomotive).FiringRateController != null)
{
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).FiringRateController.CurrentValue.ToString("F0"));
}
else
{
Logger.Data("null");
}
if ((Viewer.PlayerLocomotive as MSTSSteamLocomotive).Injector1Controller != null)
{
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).Injector1Controller.CurrentValue.ToString("F0"));
}
else
{
Logger.Data("null");
}
if ((Viewer.PlayerLocomotive as MSTSSteamLocomotive).Injector2Controller != null)
{
Logger.Data((Viewer.PlayerLocomotive as MSTSSteamLocomotive).Injector2Controller.CurrentValue.ToString("F0"));
}
else
{
Logger.Data("null");
}
}
#endif
}
Logger.End();
#if DEBUG_DUMP_STEAM_POWER_CURVE
}
#endif
}
}
public override float Update(float elapsedSeconds)
{
if (TCSEmergencyBraking())
{
allowConnect = true;
}
if (client == null && allowConnect)
{
TcpClient c = new TcpClient();
c.Connect("127.0.0.1", 5090);
client = new TCPClient(c);
client.WriteLine("register(train_brake)");
client.WriteLine("register(emergency_pushb)");
client.WriteLine("register(power)");
client.WriteLine("register(speed)");
}
if (client != null)
{
string line = client.ReadLine();
while (line != null)
{
string val = line.Substring(line.IndexOf('=') + 1);
if (line.StartsWith("train_brake="))
{
Value = float.Parse(val.Replace('.', ','));
}
else if (line.StartsWith("emergency_pushb="))
{
EBPB = val != "0" && val != "false";
}
else if (line.StartsWith("power="))
{
power = val == "1" || val == "true";
}
else if (line.StartsWith("speed="))
{
speed = MpS.FromKpH(float.Parse(val.Replace('.', ',')));
}
line = client.ReadLine();
}
}
if (UpdateValue() == 1)
{
if (Value > 0.9)
{
Value = 1;
SetUpdateValue(0);
}
else
{
float prev = Value;
Value += elapsedSeconds / 3;
if (Value >= 0.9 && prev < 0.9)
{
Value = 0.93f;
SetUpdateValue(0);
}
}
}
if (UpdateValue() == -1)
{
float prev = Value;
Value -= elapsedSeconds / 3;
if (Value <= 0)
{
Value = 0;
SetUpdateValue(0);
}
}
if (EBPB || EmergencyBrakingPushButton() || TCSEmergencyBraking() || Value > 0.95f)
{
CurrentState = State.Emergency;
}
else if (TCSFullServiceBraking() || Value > 0.90f)
{
CurrentState = State.FullBrake;
}
else if (Value > 0.01)
{
CurrentState = State.Apply;
}
else
{
CurrentState = State.Release;
}
if (Value < 0.01)
{
applyValue = 0;
}
else
{
applyValue = Math.Min(Math.Max(Value * 0.9f, 0), 1);
}
airBrakeValue = applyValue;
SetCurrentValue(Value);
return(CurrentValue());
}
