Exemple #1
0
        private int KickStart(int currentSpeed, Locomotive ecosLoc)
        {
            var maxSpeedSteps = ecosLoc.GetNumberOfSpeedsteps();
            var previousSpeed = currentSpeed;

            var kickStartSpeed = 0;

            if (maxSpeedSteps <= 14)
            {
                kickStartSpeed = Globals.DccKickStartM14;
            }
            else if (maxSpeedSteps <= 28)
            {
                kickStartSpeed = Globals.DccKickStartM28;
            }
            else if (maxSpeedSteps <= 128)
            {
                kickStartSpeed = Globals.DccKickStartM128;
            }

            if (currentSpeed > kickStartSpeed)
            {
                return(currentSpeed);
            }

            __showSpeed(kickStartSpeed);
            Ctx.GetClientHandler()?.LocomotiveChangeSpeedstep(ecosLoc, kickStartSpeed);
            System.Threading.Thread.Sleep(Globals.DccKickStartDelayMsecs);
            if (previousSpeed < 1)
            {
                previousSpeed = 2;
            }
            __showSpeed(previousSpeed);
            Ctx.GetClientHandler()?.LocomotiveChangeSpeedstep(ecosLoc, previousSpeed);
            return(previousSpeed);
        }
Exemple #2
0
        private async Task DecelerateLocomotiveCurve(
            Locomotive ecosLoc,
            SpeedCurve speedCurve,
            int maxSeconds = -1,
            Func <bool> hasToBeCanceled = null
            )
        {
            if (maxSeconds <= -1)
            {
                maxSeconds = speedCurve.MaxTime;
            }

            var currentSpeed   = (float)ecosLoc.Speedstep;
            var maxSpeed       = speedCurve.MaxSpeed;
            var noOfSpeedsteps = ecosLoc.GetNumberOfSpeedsteps();
            var minSpeed       = GetMinSpeed(noOfSpeedsteps);
            var timeSteps      = (speedCurve.MaxTime / (float)maxSpeed) * 1000.0;

            await Task.Run(() =>
            {
                //
                // IMPORTANT NOTE:
                // do not slow down the locomotive completly
                // we still have to reach the fbIn, when reached
                // the train will stop right at this moment
                //

                var sw  = Stopwatch.StartNew();
                var idx = -1;
                for (var i = 0; i < speedCurve.Steps.Count - 1; ++i)
                {
                    var s0 = speedCurve.Steps[i];
                    var s1 = speedCurve.Steps[i + 1];
                    if (currentSpeed >= s0.Speed && currentSpeed < s1.Speed)
                    {
                        idx = i;
                        break;
                    }
                }

                if (idx == -1)
                {
                    idx = speedCurve.Steps.Count - 1;
                }

                for (var i = idx; i > minSpeed; --i)
                {
                    var nextSpeed = speedCurve.Steps[i];

                    //
                    // walltime reached
                    //
                    if (sw.ElapsedMilliseconds / 1000 > maxSeconds)
                    {
                        return;
                    }

                    Ctx.GetClientHandler()?.LocomotiveChangeSpeedstep(ecosLoc, (int)nextSpeed.Speed);

                    __showSpeed((int)nextSpeed.Speed);

                    if (IsCanceled())
                    {
                        Ctx.GetClientHandler()?.LocomotiveChangeSpeedstep(ecosLoc, 0);

                        return;
                    }

                    if (hasToBeCanceled != null)
                    {
                        if (hasToBeCanceled())
                        {
                            return;
                        }
                    }

                    if (__delayDecelerate((int)timeSteps, sw, maxSeconds, hasToBeCanceled))
                    {
                        return;
                    }

                    if (hasToBeCanceled != null)
                    {
                        if (hasToBeCanceled())
                        {
                            return;
                        }
                    }
                }
            }, CancelSource.Token);
        }
Exemple #3
0
        private async Task DecelerateLocomotive(
            Locomotive ecosLoc,
            int maxSecsToStop           = 10,
            Func <bool> hasToBeCanceled = null)
        {
            var currentSpeed    = (float)ecosLoc.Speedstep;
            var deltaSpeedSteps = maxSecsToStop / currentSpeed; //currentSpeed / maxSecsToStop;
            var noOfSpeedsteps  = ecosLoc.GetNumberOfSpeedsteps();
            var minSpeed        = GetMinSpeed(noOfSpeedsteps);

            await Task.Run(() =>
            {
                //
                // IMPORTANT NOTE:
                // do not slow down the locomotive completly
                // we still have to reach the fbIn, when reached
                // the train will stop right at this moment
                //

                var sw = Stopwatch.StartNew();

                for (var i = currentSpeed; i > minSpeed; i -= deltaSpeedSteps)
                {
                    //
                    // walltime reached
                    //
                    if (sw.ElapsedMilliseconds / 1000 > maxSecsToStop)
                    {
                        return;
                    }

                    __showSpeed((int)i);

                    Ctx.GetClientHandler()?.LocomotiveChangeSpeedstep(ecosLoc, (int)i);

                    if (IsCanceled())
                    {
                        Ctx.GetClientHandler()?.LocomotiveChangeSpeedstep(ecosLoc, 0);

                        break;
                    }

                    if (hasToBeCanceled != null)
                    {
                        if (hasToBeCanceled())
                        {
                            break;
                        }
                    }

                    if (__delayDecelerate((int)deltaSpeedSteps, sw, maxSecsToStop, hasToBeCanceled))
                    {
                        return;
                    }

                    if (hasToBeCanceled != null)
                    {
                        if (hasToBeCanceled())
                        {
                            break;
                        }
                    }
                }
            }, CancelSource.Token);
        }
Exemple #4
0
        private async Task AccelerateLocomotive(
            int currentSpeed,
            int targetSpeed,
            Locomotive ecosLoc,
            int maxSeconds = 10,
            Func <bool> hasToBeCanceled = null)
        {
            var maxSpeedSteps = ecosLoc.GetNumberOfSpeedsteps();
            var msecsDelay    = maxSpeedSteps < 30 ? 1000 : 250;

            await Task.Run(() =>
            {
                currentSpeed = KickStart(currentSpeed, ecosLoc);

                var hasCanceled     = false;
                var newCurrentSpeed = currentSpeed;

                var sw = Stopwatch.StartNew();

                for (var i = currentSpeed; i <= targetSpeed; ++i)
                {
                    __showSpeed(i);

                    Ctx.GetClientHandler()?.LocomotiveChangeSpeedstep(ecosLoc, i);

                    newCurrentSpeed = i;

                    if (IsCanceled())
                    {
                        hasCanceled = true;
                        break;
                    }

                    if (hasToBeCanceled != null)
                    {
                        if (hasToBeCanceled())
                        {
                            break;
                        }
                    }

                    if (__delayAccelerate(msecsDelay, sw, maxSeconds, hasToBeCanceled))
                    {
                        return;
                    }

                    if (hasToBeCanceled != null)
                    {
                        if (hasToBeCanceled())
                        {
                            break;
                        }
                    }
                }

                if (!hasCanceled)
                {
                    Ctx.GetClientHandler()?.LocomotiveChangeSpeedstep(ecosLoc, newCurrentSpeed);
                }
            }, CancelSource.Token);
        }