Esempio n. 1
0
        public PowertrainECU300(VehicleDB db, ICommbox box, PowertrainModel model)
            : base(db, box)
        {
            switch (model)
            {
                case PowertrainModel.QM48QT_8:
                    Parameter.KLineParity = KLineParity.None;
                    Parameter.KLineBaudRate = 19200;
                    Channel = ChannelFactory.Create(Parameter, box, ProtocolType.MikuniECU300);
                    Format = new MikuniECU300Format(Parameter);
                    break;
                default:
                    throw new DiagException("Unsupport model!");
            }
            startConnection = Format.Pack(Database.QueryCommand("Start Connection", "Mikuni ECU300"));
            tpsIdleLearningValueSetting = Format.Pack(Database.QueryCommand("TPS Idle Learning Value Setting", "Mikuni ECU300"));
            longTermLearningValueReset = Format.Pack(Database.QueryCommand("02 Feed Back Long Term Learning Value Reset", "Mikuni ECU300"));
            dsvISCLearningValueSetting = Format.Pack(Database.QueryCommand("DSV ISC Learning Value Reset", "Mikuni ECU300"));
            readEcuVersion = Format.Pack(Database.QueryCommand("ECU Version Information", "Mikuni ECU300"));

            this.model = model;
            rData = new byte[128];

            DataStream = new PowertrainDataStreamECU300(this);
        }
        public PowertrainDataStreamECU300(PowertrainECU300 ecu)
            : base(ecu.Database, ecu.Channel, ecu.Format)
        {
            model = ecu.Model;

            switch (model)
            {
                case PowertrainModel.QM48QT_8:
                    if (!QueryLiveData("QingQi Mikuni ECU300"))
                    {
                        throw new DiagException("Cannot find live datas");
                    }

                    foreach (var item in LiveDataItems)
                    {
                        item.FormattedCommand = Format.Pack(item.Command);
                        item.IsEnabled = true;
                    }

                    LiveDataItems["TS"].IsEnabled = false;
                    break;
                default:
                    throw new DiagException("Unsupport model");
            }

            ReadInterval = Timer.FromMilliseconds(10);
        }
Esempio n. 3
0
        public PowertrainECU200(VehicleDB db, ICommbox box, PowertrainModel model)
            : base(db, box)
        {
            switch (model)
            {
                case PowertrainModel.DCJ_16A:
                case PowertrainModel.DCJ_16C:
                case PowertrainModel.DCJ_10:
                    Parameter.KLineParity = KLineParity.None;
                    Parameter.KLineBaudRate = 19200;
                    Channel = ChannelFactory.Create(Parameter, box, ProtocolType.MikuniECU200);
                    Format = new MikuniECU200Format(Parameter);
                    break;
                case PowertrainModel.QM200GY_F:
                case PowertrainModel.QM200_3D:
                case PowertrainModel.QM200J_3L:
                    Parameter.KLineParity = KLineParity.Even;
                    Parameter.KLineBaudRate = 19200;
                    Channel = ChannelFactory.Create(Parameter, box, ProtocolType.MikuniECU300);
                    Format = new MikuniECU200Format(Parameter);
                    break;
                default:
                    throw new DiagException("Unsupport model!");
            }
            this.model = model;
            if (Channel == null)
                throw new DiagException("Cannot create channel!!!");

            readECUVersion1 = Format.Pack(Database.QueryCommand("Read ECU Version 1", "Mikuni ECU200"));
            readECUVersion2 = Format.Pack(Database.QueryCommand("Read ECU Version 2", "Mikuni ECU200"));
            engineRevolutions = Format.Pack(Database.QueryCommand("Engine Revolutions", "Mikuni ECU200"));
            tpsIdleAdjustments = Format.Pack(Database.QueryCommand("TPS Idle Adjustment", "Mikuni ECU200"));
            longTermLearnValueZoneInitialization = Format.Pack(Database.QueryCommand("Long Term Learn Value Zone Initialization", "Mikuni ECU200"));
            longTermLearnValueZones = new Dictionary<int, byte[]>();
            for (int i = 1; i < 11; i++)
            {
                longTermLearnValueZones.Add(i,
                    Format.Pack(
                        Database.QueryCommand(
                            "Long Term Learn Value Zone_" + Convert.ToString(i), "Mikuni ECU200")
                    )
                );
            }
            iscLearnValueInitialization = Format.Pack(Database.QueryCommand("ISC Learn Value Initialization", "Mikuni ECU200"));
            rData = new byte[100];

            DataStream = new PowertrainDataStreamECU200(this);
            TroubleCode = new PowertrainTroubleCodeECU200(this);
        }
        public PowertrainTroubleCodeECU300(PowertrainECU300 ecu)
            : base(ecu.Database, ecu.Channel, ecu.Format)
        {
            syntheticFailure = Format.Pack(Database.QueryCommand("Synthetic Failure", "Mikuni ECU300"));

            failureCmds = new Dictionary<int, byte[]>();
            failureCalcs = new Dictionary<int, Func<byte[], int, int, string>>();

            byte[] cmd = Database.QueryCommand("O2 Sensor Failure", "Mikuni ECU300");
            failureCmds.Add(1, Format.Pack(cmd));
            failureCalcs.Add(1, (recv, offset, count) =>
            {
                return CalcTroubleCode(recv, offset, count, "0140", "0180");
            });

            cmd = Database.QueryCommand("TPS Value Failure", "Mikuni ECU300");
            failureCmds.Add(2, Format.Pack(cmd));
            failureCalcs.Add(2, (recv, offset, count) =>
            {
                return CalcTroubleCode(recv, offset, count, "0240", "0280");
            });

            cmd = Database.QueryCommand("Sensor Source Failure", "Mikuni ECU300");
            failureCmds.Add(3, Format.Pack(cmd));
            failureCalcs.Add(3, (recv, offset, count) =>
            {
                return CalcTroubleCode(recv, offset, count, "0340", "0380");
            });

            cmd = Database.QueryCommand("Battery Voltage Failure", "Mikuni ECU300");
            failureCmds.Add(4, Format.Pack(cmd));
            failureCalcs.Add(4, (recv, offset, count) =>
            {
                return CalcTroubleCode(recv, offset, count, "0540", "0580");
            });

            cmd = Database.QueryCommand("Engine Temperature Sensor Failure", "Mikuni ECU300");
            failureCmds.Add(5, Format.Pack(cmd));
            failureCalcs.Add(5, (recv, offset, count) =>
            {
                return CalcTroubleCode(recv, offset, count, "0640", "0680");
            });

            cmd = Database.QueryCommand("Tilt Sensor Failure", "Mikuni ECU300");
            failureCmds.Add(6, Format.Pack(cmd));
            failureCalcs.Add(6, (recv, offset, count) =>
            {
                return CalcTroubleCode(recv, offset, count, "0880", "0880");
            });

            cmd = Database.QueryCommand("Injector Failure", "Mikuni ECU300");
            failureCmds.Add(7, Format.Pack(cmd));
            failureCalcs.Add(7, (recv, offset, count) =>
            {
                return CalcTroubleCode(recv, offset, count, "2040", "2080");
            });

            cmd = Database.QueryCommand("Ignition Coil Failure", "Mikuni ECU300");
            failureCmds.Add(8, Format.Pack(cmd));
            failureCalcs.Add(8, (recv, offset, count) =>
            {
                return CalcTroubleCode(recv, offset, count, "2140", "2180");
            });

            cmd = Database.QueryCommand("DSV Failure", "Mikuni ECU300");
            failureCmds.Add(9, Format.Pack(cmd));
            failureCalcs.Add(9, (recv, offset, count) =>
            {
                return CalcTroubleCode(recv, offset, count, "2840", "2880");
            });

            cmd = Database.QueryCommand("PDP Failure", "Mikuni ECU300");
            failureCmds.Add(10, Format.Pack(cmd));
            failureCalcs.Add(10, (recv, offset, count) =>
            {
                return CalcTroubleCode(recv, offset, count, "2740", "2780");
            });

            cmd = Database.QueryCommand("EEPROM Failure", "Mikuni ECU300");
            failureCmds.Add(11, Format.Pack(cmd));
            failureCalcs.Add(11, (recv, offset, count) =>
            {
                return CalcTroubleCode(recv, offset, count, "4040", "4080");
            });

            failureHistoryPointer = Format.Pack(Database.QueryCommand("Failure History Pointer", "Mikuni ECU300"));

            failureHistoryBuffer = new Dictionary<int, byte[]>();
            for (int i = 1; i < 17; i++)
            {
                cmd = Database.QueryCommand("Failure History Buffer" + Convert.ToString(i), "Mikuni ECU300");
                failureHistoryBuffer.Add(i, Format.Pack(cmd));
            }

            failureHistoryClear1 = Format.Pack(Database.QueryCommand("Failure History Clear1", "Mikuni ECU300"));

            failureHistoryClear2 = Format.Pack(Database.QueryCommand("Failure History Clear2", "Mikuni ECU300"));

            failureHistoryClear3 = Format.Pack(Database.QueryCommand("Failure History Clear3", "Mikuni ECU300"));

            this.ecu = ecu;
            this.model = ecu.Model;

            switch (model)
            {
                case PowertrainModel.QM48QT_8:
                    sys = "QingQi Mikuni ECU300";
                    break;
                default:
                    break;
            }

            rData = new byte[128];
        }
        public PowertrainTroubleCodeECU200(PowertrainECU200 ecu)
            : base(ecu.Database, ecu.Channel, ecu.Format)
        {
            syntheticFailure = Format.Pack(Database.QueryCommand("Synthetic Failure", "Mikuni ECU200"));

            failureCmds = new Dictionary<int, byte[]>();
            failureCalcs = new Dictionary<int, Func<byte[], int, int, string>>();

            failureCmds.Add(1, Format.Pack(Database.QueryCommand("Manifold Pressure Failure", "Mikuni ECU200")));
            failureCalcs.Add(1, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "0040", "0080");
            });

            failureCmds.Add(2, Format.Pack(Database.QueryCommand("O2 Sensor Failure", "Mikuni ECU200")));
            failureCalcs.Add(2, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "0140", "0180");
            });

            failureCmds.Add(3, Format.Pack(Database.QueryCommand("TPS Sensor Failure", "Mikuni ECU200")));
            failureCalcs.Add(3, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "0240", "0280");
            });

            failureCmds.Add(4, Format.Pack(Database.QueryCommand("Sensor Source Failure", "Mikuni ECU200")));
            failureCalcs.Add(4, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "0340", "0380");
            });

            failureCmds.Add(5, Format.Pack(Database.QueryCommand("Battery Voltage Failure", "Mikuni ECU200")));
            failureCalcs.Add(5, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "0540", "0580");
            });

            failureCmds.Add(6, Format.Pack(Database.QueryCommand("Engine Temperature Sensor Failure", "Mikuni ECU200")));
            failureCalcs.Add(6, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "0640", "0680");
            });

            failureCmds.Add(7, Format.Pack(Database.QueryCommand("Manifold Temperature Failure", "Mikuni ECU200")));
            failureCalcs.Add(7, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "0740", "0780");
            });

            failureCmds.Add(8, Format.Pack(Database.QueryCommand("Tilt Sensor Failure", "Mikuni ECU200")));
            failureCalcs.Add(8, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "0840", "0880");
            });

            failureCmds.Add(9, Format.Pack(Database.QueryCommand("DCP Failure", "Mikuni ECU200")));
            failureCalcs.Add(9, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "2040", "2080");
            });

            failureCmds.Add(10, Format.Pack(Database.QueryCommand("Ignition Coil Failure", "Mikuni ECU200")));
            failureCalcs.Add(10, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "2140", "2180");
            });

            failureCmds.Add(11, Format.Pack(Database.QueryCommand("O2 Heater Failure", "Mikuni ECU200")));
            failureCalcs.Add(11, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "2240", "2280");
            });

            failureCmds.Add(11, Format.Pack(Database.QueryCommand("EEPROM Failure", "Mikuni ECU200")));
            failureCalcs.Add(11, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "4040", "4080");
            });

            failureCmds.Add(11, Format.Pack(Database.QueryCommand("Air Valve Failure", "Mikuni ECU200")));
            failureCalcs.Add(11, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "2340", "2380");
            });

            failureCmds.Add(11, Format.Pack(Database.QueryCommand("SAV Failure", "Mikuni ECU200")));
            failureCalcs.Add(11, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "2440", "2480");
            });

            failureCmds.Add(11, Format.Pack(Database.QueryCommand("CPS Failure", "Mikuni ECU200")));
            failureCalcs.Add(11, (buff, offset, length) =>
            {
                return CalcTroubleCode(buff, offset, length, "0940", "0980");
            });

            failureHistoryPointer = Format.Pack(Database.QueryCommand("Failure History Pointer", "Mikuni ECU200"));

            failureHistoryBuffer = new Dictionary<int, byte[]>();
            for (int i = 0; i < 16; i++)
            {
                failureHistoryBuffer.Add(i,
                    Format.Pack(
                        Database.QueryCommand(
                            "Failure History Buffer" + Convert.ToInt32(i), "Mikuni ECU200")
                    )
                );
            }

            failureHistoryClear = Format.Pack(Database.QueryCommand("Failure History Clear", "Mikuni ECU200"));

            model = ecu.Model;
            switch (model)
            {
                case PowertrainModel.DCJ_16A:
                case PowertrainModel.DCJ_16C:
                case PowertrainModel.DCJ_10:
                    sys = "DCJ Mikuni ECU200";
                    break;
                case PowertrainModel.QM200GY_F:
                case PowertrainModel.QM200_3D:
                case PowertrainModel.QM200J_3L:
                    sys = "QingQi Mikuni ECU200";
                    break;
                default:
                    break;
            }

            rData = new byte[100];
        }