Beispiel #1
0
        public void TickTelemetry(IDataMiner data)
        {
            if (!Main.Data.Active.SupportsCar)
            {
                return;
            }
            bool wasCalibrating = Calibrating;

            Calibrating = !Main.Drivetrain.Calibrated;
            if (!wasCalibrating && Calibrating)
            {
                Debug.WriteLine("now calibrating");
                stage = DrivetrainCalibrationStage.StartIdleRpm;
            }

            if (stage != DrivetrainCalibrationStage.None && !Calibrating)
            {
                stage = DrivetrainCalibrationStage.None;
            }
            ;
            switch (stage)
            {
            case DrivetrainCalibrationStage.None:
                reqGears    = false;
                reqThrottle = false;
                reqClutch   = false;
                break;

            case DrivetrainCalibrationStage.StartIdleRpm:

                reqClutch   = true;
                reqThrottle = true;
                reqGears    = true;
                Main.Transmission.Shift(data.Telemetry.Gear, 0, calibrateShiftStyle);
                if (data.Telemetry.EngineRpm < 300)
                {
                    throttle = 1;
                    clutch   = 1;
                    gear     = 0;
                }
                else if (data.Telemetry.EngineRpm > 2000)
                {
                    throttle = 0;
                    clutch   = 1;
                    gear     = 0;
                }
                else
                {
                    throttle = 0;
                    clutch   = 1;
                    gear     = 0;

                    if (Math.Abs(data.Telemetry.EngineRpm - previousEngineRpm) < 1)
                    {
                        stage = DrivetrainCalibrationStage.FinishIdleRpm;

                        MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, 2750));
                    }
                }
                previousEngineRpm = data.Telemetry.EngineRpm;
                break;

            case DrivetrainCalibrationStage.FinishIdleRpm:
                if (MeasurementSettled)
                {
                    Debug.WriteLine("Idle RPM: " + data.Telemetry.EngineRpm);
                    if (data.Telemetry.EngineRpm < 300)
                    {
                        stage = DrivetrainCalibrationStage.StartIdleRpm;
                    }
                    else
                    {
                        Main.Drivetrain.StallRpm = data.Telemetry.EngineRpm;

                        stage            = DrivetrainCalibrationStage.StartMaxRpm;
                        maxRpmTarget     = data.Telemetry.EngineRpm + 1000;
                        previousThrottle = 0;
                    }
                }
                break;

            case DrivetrainCalibrationStage.StartMaxRpm:
                reqClutch   = true;
                reqThrottle = true;
                reqGears    = true;

                clutch         = 1;
                throttle       = 1;
                maxRpmMeasured = 0;

                MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, 1500));
                stage = DrivetrainCalibrationStage.FinishMaxRpm;

                break;

            case DrivetrainCalibrationStage.FinishMaxRpm:

                throttle       = 1;
                maxRpmMeasured = Math.Max(maxRpmMeasured, data.Telemetry.EngineRpm);

                if (MeasurementSettled)
                {
                    if (Math.Abs(maxRpmMeasured - Main.Drivetrain.StallRpm) < 500)
                    {
                        Debug.WriteLine("Totally messed up MAX RPM.. resetting");
                        stage = DrivetrainCalibrationStage.StartIdleRpm;
                    }
                    else
                    {
                        Debug.WriteLine("Max RPM approx: " + maxRpmMeasured);

                        Main.Drivetrain.MaximumRpm = maxRpmMeasured - 300;

                        stage     = DrivetrainCalibrationStage.ShiftToFirst;
                        nextStage = DrivetrainCalibrationStage.StartGears;
                    }
                }
                break;

            case DrivetrainCalibrationStage.StartGears:
                reqClutch   = true;
                reqThrottle = true;
                reqGears    = true;

                throttle = 0;
                clutch   = 1;
                gear++;
                Main.Transmission.Shift(data.Telemetry.Gear, gear, calibrateShiftStyle);
                MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, 500));

                stage = DrivetrainCalibrationStage.FinishGears;

                break;

            case DrivetrainCalibrationStage.FinishGears:

                if (MeasurementSettled && !Main.Transmission.IsShifting)
                {
                    if (data.Telemetry.Gear != gear)
                    {
                        gear--;
                        // Car doesn't have this gear.
                        Debug.WriteLine("Gears: " + gear);

                        if (gear <= 0)
                        {
                            Debug.WriteLine("That's not right");
                            stage = DrivetrainCalibrationStage.StartGears;
                        }
                        else
                        {
                            Main.Drivetrain.Gears      = gear;
                            Main.Drivetrain.GearRatios = new double[gear];

                            stage                 = DrivetrainCalibrationStage.ShiftToFirst;
                            nextStage             = DrivetrainCalibrationStage.StartGearRatios;
                            MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, 500));
                            calibrationPreDone    = false;
                        }
                        gear = 0;
                    }
                    else
                    {
                        stage = DrivetrainCalibrationStage.StartGears;
                    }
                }
                break;

            case DrivetrainCalibrationStage.ShiftToFirst:
                if (!Main.Transmission.IsShifting && MeasurementSettled)
                {
                    if (data.Telemetry.Gear != 1)
                    {
                        Main.Transmission.Shift(shiftToFirstRangeAttempt * Main.Transmission.RangeSize + 1, 1, calibrateShiftStyle);
                        shiftToFirstRangeAttempt++;

                        MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, 100));
                        if (shiftToFirstRangeAttempt > 3)
                        {
                            shiftToFirstRangeAttempt = 0;
                        }
                    }
                    else
                    {
                        stage = nextStage;
                        MeasurementSettletime = DateTime.MaxValue;
                    }
                }

                break;

            case DrivetrainCalibrationStage.EndGearRatios:

                if (Main.Drivetrain.GearRatios.Length >= data.Telemetry.Gear)
                {
                    if (data.Telemetry.Gear <= 0)
                    {
                        stage = DrivetrainCalibrationStage.StartGearRatios;
                        break;
                    }
                    if (data.Telemetry.EngineRpm > Main.Drivetrain.StallRpm * 1.15)
                    {
                        var gr = Main.Drivetrain.GearRatios[data.Telemetry.Gear - 1];
                        if (gr != 0)
                        {
                            stage = DrivetrainCalibrationStage.StartGearRatios;
                            break;
                        }
                        reqThrottle = true;
                        throttle    = gearRatioSpeedCruise - data.Telemetry.Speed;
                        throttle   /= 3;

                        var ratio = data.Telemetry.EngineRpm / (3.6 * data.Telemetry.Speed);
                        if (ratio > 1000 || ratio < 1)
                        {
                            stage = DrivetrainCalibrationStage.StartGearRatios;
                            break;
                        }

                        Debug.WriteLine("Gear " + data.Telemetry.Gear + " : " + ratio);

                        // start sampling
                        if (sample == 0)
                        {
                            sample = ratio;
                        }
                        else
                        {
                            sample = sample * 0.9 + ratio * 0.1;
                        }
                        samplesTaken++;

                        if (samplesTaken == 50)
                        {
                            Main.Drivetrain.GearRatios[data.Telemetry.Gear - 1] = sample;
                        }
                    }
                    else
                    {
                        stage = DrivetrainCalibrationStage.StartGearRatios;
                        break;
                    }
                }
                else
                {
                    stage = DrivetrainCalibrationStage.StartGearRatios;
                }
                break;

            case DrivetrainCalibrationStage.StartGearRatios:

                reqGears    = false;
                reqThrottle = false;
                reqClutch   = false;

                // Activate get-home-mode; which shifts at 4x stall rpm
                Main.Transmission.GetHomeMode = true;

                if (data.Telemetry.EngineRpm > Main.Drivetrain.StallRpm * 2)
                {
                    // Driving at reasonable rpm's.

                    if (data.Telemetry.Gear > 0)
                    {
                        if (Main.Drivetrain.GearRatios.Length >= data.Telemetry.Gear && data.Telemetry.EngineRpm > Main.Drivetrain.StallRpm * 2)
                        {
                            var gr = Main.Drivetrain.GearRatios[data.Telemetry.Gear - 1];

                            if (gr == 0)
                            {
                                samplesTaken         = 0;
                                gearRatioSpeedCruise = data.Telemetry.Speed;
                                stage = DrivetrainCalibrationStage.EndGearRatios;
                            }
                        }
                    }

                    var GearsCalibrated = true;
                    for (int i = 0; i < Main.Drivetrain.Gears; i++)
                    {
                        if (Main.Drivetrain.GearRatios[i] < 1)
                        {
                            UncalibratedGear = i;

                            GearsCalibrated = false;
                        }
                    }

                    if (GearsCalibrated)
                    {
                        if (MeasurementSettled)
                        {
                            Main.Transmission.GetHomeMode = false;
                            Debug.WriteLine("Calibration done");
                            stage = DrivetrainCalibrationStage.None;

                            Main.Store(Main.Drivetrain.ExportParameters(), Main.Drivetrain.File);
                            Main.Load(Main.Drivetrain, Main.Drivetrain.File);
                        }

                        if (!calibrationPreDone)
                        {
                            calibrationPreDone    = true;
                            MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 3));
                        }
                    }
                }

                break;
            }
        }
        public void TickTelemetry(IDataMiner data)
        {
            if (!Main.Data.Active.SupportsCar) return;
            bool wasCalibrating = Calibrating;
            Calibrating = !Main.Drivetrain.Calibrated;
            if(!wasCalibrating && Calibrating)
            {
                Debug.WriteLine("now calibrating");
                stage = DrivetrainCalibrationStage.StartIdleRpm;
            }

            if(stage!=DrivetrainCalibrationStage.None && !Calibrating)
                stage = DrivetrainCalibrationStage.None;
            ;
            switch(stage)
            {
                case DrivetrainCalibrationStage.None :
                    reqGears = false;
                    reqThrottle = false;
                    reqClutch = false;
                    break;

                case DrivetrainCalibrationStage.StartIdleRpm:

                    reqClutch = true;
                    reqThrottle = true;
                    reqGears = true;
                    Main.Transmission.Shift(data.Telemetry.Gear, 0, calibrateShiftStyle);
                    if (data.Telemetry.EngineRpm < 300)
                    {
                        throttle = 1;
                        clutch = 1;
                        gear = 0;
                    }
                    else if (data.Telemetry.EngineRpm>2000)
                    {
                        throttle = 0;
                        clutch = 1;
                        gear = 0;
                    }else
                    {
                        throttle = 0;
                        clutch = 1;
                        gear = 0;

                        if (Math.Abs(data.Telemetry.EngineRpm - previousEngineRpm) < 1){
                            stage = DrivetrainCalibrationStage.FinishIdleRpm;

                            MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, 2750));
                        }
                    }
                        previousEngineRpm = data.Telemetry.EngineRpm;
                    break;
                case DrivetrainCalibrationStage.FinishIdleRpm:
                    if (MeasurementSettled)
                    {
                        Debug.WriteLine("Idle RPM: " + data.Telemetry.EngineRpm);
                        if (data.Telemetry.EngineRpm < 300)
                        {
                            stage = DrivetrainCalibrationStage.StartIdleRpm;
                        }
                        else
                        {
                            Main.Drivetrain.StallRpm = data.Telemetry.EngineRpm;

                            stage = DrivetrainCalibrationStage.StartMaxRpm;
                            maxRpmTarget = data.Telemetry.EngineRpm + 1000;
                            previousThrottle = 0;
                        }
                    }
                    break;

                case DrivetrainCalibrationStage.StartMaxRpm:
                    reqClutch = true;
                    reqThrottle = true;
                    reqGears = true;

                    clutch = 1;
                    throttle = 1;
                    maxRpmMeasured = 0;

                    MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 0,1500));
                    stage = DrivetrainCalibrationStage.FinishMaxRpm;

                    break;
                case DrivetrainCalibrationStage.FinishMaxRpm:

                    throttle = 1;
                    maxRpmMeasured = Math.Max(maxRpmMeasured, data.Telemetry.EngineRpm);

                    if (MeasurementSettled)
                    {
                        if (Math.Abs(maxRpmMeasured-Main.Drivetrain.StallRpm) < 500)
                        {
                            Debug.WriteLine("Totally messed up MAX RPM.. resetting");
                            stage = DrivetrainCalibrationStage.StartIdleRpm;
                        }
                        else
                        {
                            Debug.WriteLine("Max RPM approx: " + maxRpmMeasured);

                            Main.Drivetrain.MaximumRpm = maxRpmMeasured-300;

                            stage = DrivetrainCalibrationStage.ShiftToFirst;
                            nextStage = DrivetrainCalibrationStage.StartGears;
                        }
                    }
                    break;

                case DrivetrainCalibrationStage.StartGears:
                    reqClutch = true;
                    reqThrottle = true;
                    reqGears = true;

                    throttle = 0;
                    clutch = 1;
                    gear++;
                    Main.Transmission.Shift(data.Telemetry.Gear, gear, calibrateShiftStyle);
                    MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 0,500));

                    stage = DrivetrainCalibrationStage.FinishGears;

                    break;
                case DrivetrainCalibrationStage.FinishGears:

                    if (MeasurementSettled && !Main.Transmission.IsShifting)
                    {
                        if(data.Telemetry.Gear != gear)
                        {
                            gear--;
                            // Car doesn't have this gear.
                            Debug.WriteLine("Gears: " + gear);

                            if (gear <= 0)
                            {
                                Debug.WriteLine("That's not right");
                                stage = DrivetrainCalibrationStage.StartGears;

                            }
                            else
                            {
                                Main.Drivetrain.Gears = gear;
                                Main.Drivetrain.GearRatios = new double[gear];

                                stage = DrivetrainCalibrationStage.ShiftToFirst;
                                nextStage = DrivetrainCalibrationStage.StartGearRatios;
                                MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, 500));
                                calibrationPreDone = false;
                            }
                            gear = 0;
                        }
                        else
                        {
                            stage=DrivetrainCalibrationStage.StartGears;
                        }
                    }
                    break;

                case DrivetrainCalibrationStage.ShiftToFirst:
                    if (!Main.Transmission.IsShifting && MeasurementSettled)
                    {
                        if (data.Telemetry.Gear != 1)
                        {
                            Main.Transmission.Shift(shiftToFirstRangeAttempt*Main.Transmission.RangeSize + 1, 1,
                                                    calibrateShiftStyle);
                            shiftToFirstRangeAttempt++;

                            MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 0, 100));
                            if (shiftToFirstRangeAttempt > 3) shiftToFirstRangeAttempt = 0;
                        }
                        else
                        {
                            stage = nextStage;
                            MeasurementSettletime = DateTime.MaxValue;
                        }
                    }

                    break;

                case DrivetrainCalibrationStage.EndGearRatios:

                    if (Main.Drivetrain.GearRatios.Length >= data.Telemetry.Gear)
                    {
                        if(data.Telemetry.Gear<=0)
                        {
                            stage = DrivetrainCalibrationStage.StartGearRatios;
                            break;
                        }
                        if (data.Telemetry.EngineRpm > Main.Drivetrain.StallRpm*1.15)
                        {
                            var gr = Main.Drivetrain.GearRatios[data.Telemetry.Gear - 1];
                            if (gr != 0)
                            {
                                stage = DrivetrainCalibrationStage.StartGearRatios;
                                break;
                            }
                            reqThrottle = true;
                            throttle = gearRatioSpeedCruise - data.Telemetry.Speed;
                            throttle /= 3;

                            var ratio = data.Telemetry.EngineRpm / (3.6 * data.Telemetry.Speed);
                            if (ratio > 1000 || ratio < 1)
                            {
                                stage = DrivetrainCalibrationStage.StartGearRatios;
                                break;
                            }

                            Debug.WriteLine("Gear " + data.Telemetry.Gear + " : " + ratio);

                            // start sampling
                            if (sample == 0) sample = ratio;
                            else sample = sample * 0.9 + ratio * 0.1;
                            samplesTaken ++;

                            if(samplesTaken==50)
                            {
                                Main.Drivetrain.GearRatios[data.Telemetry.Gear - 1] = sample;
                            }
                        }
                        else
                        {
                            stage = DrivetrainCalibrationStage.StartGearRatios;
                            break;
                        }
                    }
                    else
                    {
                        stage = DrivetrainCalibrationStage.StartGearRatios;
                    }
                    break;

                case DrivetrainCalibrationStage.StartGearRatios:

                    reqGears = false;
                    reqThrottle = false;
                    reqClutch = false;

                    // Activate get-home-mode; which shifts at 4x stall rpm
                    Main.Transmission.GetHomeMode = true;

                    if (data.Telemetry.EngineRpm > Main.Drivetrain.StallRpm*2)
                    {
                        // Driving at reasonable rpm's.

                        if (data.Telemetry.Gear > 0)
                        {
                            if (Main.Drivetrain.GearRatios.Length >= data.Telemetry.Gear &&
                                data.Telemetry.EngineRpm > Main.Drivetrain.StallRpm * 2)
                            {
                                var gr = Main.Drivetrain.GearRatios[data.Telemetry.Gear - 1];

                                if (gr == 0)
                                {
                                    samplesTaken = 0;
                                    gearRatioSpeedCruise = data.Telemetry.Speed;
                                    stage = DrivetrainCalibrationStage.EndGearRatios;
                                }
                            }
                        }

                        var GearsCalibrated = true;
                        for (int i = 0; i < Main.Drivetrain.Gears; i++)
                        {    if (Main.Drivetrain.GearRatios[i] < 1)
                            {
                                UncalibratedGear = i;

                                GearsCalibrated = false;
                            }
                        }

                        if (GearsCalibrated)
                        {
                            if (MeasurementSettled)
                            {
                                Main.Transmission.GetHomeMode = false;
                                Debug.WriteLine("Calibration done");
                                stage = DrivetrainCalibrationStage.None;

                                Main.Store(Main.Drivetrain.ExportParameters(), Main.Drivetrain.File);
                                Main.Load(Main.Drivetrain, Main.Drivetrain.File);
                            }

                            if (!calibrationPreDone)
                            {
                                calibrationPreDone = true;
                                MeasurementSettletime = DateTime.Now.Add(new TimeSpan(0, 0, 0, 3));
                            }
                        }

                    }

                    break;
            }
        }