WriteLine() static private method

static private WriteLine ( ) : void
return void
Exemplo n.º 1
0
        // End top-level commands

        private void MapClusterEeprom(IKW1281Dialog kwp1281)
        {
            // Unlock partial EEPROM read
            _ = kwp1281.SendCustom(new List <byte> {
                0x9D, 0x39, 0x34, 0x34, 0x40
            });

            var        bytes     = new List <byte>();
            const byte blockSize = 1;

            for (ushort addr = 0; addr < 2048; addr += blockSize)
            {
                var blockBytes = kwp1281.ReadEeprom(addr, blockSize);
                blockBytes = Enumerable.Repeat(
                    blockBytes == null ? (byte)0 : (byte)0xFF,
                    blockSize).ToList();
                bytes.AddRange(blockBytes);
            }
            var dumpFileName = _filename ?? "eeprom_map.bin";

            Logger.WriteLine($"Saving EEPROM map to {dumpFileName}");
            File.WriteAllBytes(dumpFileName, bytes.ToArray());
        }
Exemplo n.º 2
0
        void Run(string[] args)
        {
            var version = GetType().GetTypeInfo().Assembly
                          .GetCustomAttribute <AssemblyInformationalVersionAttribute>()
                          .InformationalVersion;

            Logger.WriteLine($"KW1281Test {version} (https://github.com/gmenounos/kw1281test/releases)");
            Logger.WriteLine($"Args: {string.Join(' ', args)}");

            if (args.Length < 4)
            {
                ShowUsage();
                return;
            }

            // This seems to increase the accuracy of our timing loops
            Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.RealTime;

            string portName = args[0];
            var    baudRate = int.Parse(args[1]);

            _controllerAddress = int.Parse(args[2], NumberStyles.HexNumber);
            var  command        = args[3];
            uint address        = 0;
            uint length         = 0;
            byte value          = 0;
            int  softwareCoding = 0;
            int  workshopCode   = 0;

            if (string.Compare(command, "ReadEeprom", true) == 0)
            {
                if (args.Length < 5)
                {
                    ShowUsage();
                    return;
                }

                address = Utils.ParseUint(args[4]);
            }
            else if (string.Compare(command, "DumpMarelliMem", true) == 0 ||
                     string.Compare(command, "DumpEeprom", true) == 0 ||
                     string.Compare(command, "DumpMem", true) == 0 ||
                     string.Compare(command, "DumpRB8Eeprom", true) == 0)
            {
                if (args.Length < 6)
                {
                    ShowUsage();
                    return;
                }

                address = Utils.ParseUint(args[4]);
                length  = Utils.ParseUint(args[5]);

                if (args.Length > 6)
                {
                    _filename = args[6];
                }
            }
            else if (string.Compare(command, "WriteEeprom", true) == 0)
            {
                if (args.Length < 6)
                {
                    ShowUsage();
                    return;
                }

                address = Utils.ParseUint(args[4]);
                value   = (byte)Utils.ParseUint(args[5]);
            }
            else if (string.Compare(command, "LoadEeprom", true) == 0)
            {
                if (args.Length < 6)
                {
                    ShowUsage();
                    return;
                }

                address   = Utils.ParseUint(args[4]);
                _filename = args[5];
            }
            else if (string.Compare(command, "SetSoftwareCoding", true) == 0)
            {
                if (args.Length < 6)
                {
                    ShowUsage();
                    return;
                }

                softwareCoding = (int)Utils.ParseUint(args[4]);
                if (softwareCoding > 32767)
                {
                    Logger.WriteLine("SoftwareCoding cannot be greater than 32767.");
                    return;
                }
                workshopCode = (int)Utils.ParseUint(args[5]);
                if (workshopCode > 99999)
                {
                    Logger.WriteLine("WorkshopCode cannot be greater than 99999.");
                    return;
                }
            }
            else if (string.Compare(command, "DumpEdc15Eeprom", true) == 0)
            {
                if (args.Length < 4)
                {
                    ShowUsage();
                    return;
                }

                if (args.Length > 4)
                {
                    _filename = args[4];
                }
            }

            using var @interface = OpenPort(portName, baudRate);

            _kwpCommon = new KwpCommon(@interface);

            switch (command.ToLower())
            {
            case "actuatortest":
                Kwp1281Wakeup();
                ActuatorTest(_kwp1281);
                break;

            case "clearfaultcodes":
                Kwp1281Wakeup();
                ClearFaultCodes(_kwp1281);
                break;

            case "delcovwpremium5safecode":
                Kwp1281Wakeup();
                DelcoVWPremium5SafeCode(_kwp1281);
                break;

            case "dumpccmrom":
                Kwp1281Wakeup();
                DumpCcmRom(_kwp1281);
                break;

            case "dumpclusternecrom":
                Kwp1281Wakeup();
                DumpClusterNecRom(_kwp1281);
                break;

            case "dumpedc15eeprom":
                DumpEdc15Eeprom();
                break;

            case "dumpeeprom":
                Kwp1281Wakeup();
                DumpEeprom(_kwp1281, address, length);
                break;

            case "dumpmarellimem":
                var ecuInfo = Kwp1281Wakeup();
                if (_controllerAddress != (int)ControllerAddress.Cluster)
                {
                    Logger.WriteLine("Only supported for clusters");
                }
                else
                {
                    MarelliCluster.DumpMem(
                        _kwp1281, ecuInfo, _filename, (ushort)address, (ushort)length);
                }
                return;

            case "dumpmem":
                Kwp1281Wakeup();
                DumpMem(_kwp1281, address, length);
                break;

            case "dumprb8eeprom":
                DumpRB8Eeprom(Kwp2000Wakeup(evenParityWakeup: true), address, length);
                break;

            case "loadeeprom":
                Kwp1281Wakeup();
                LoadEeprom(_kwp1281, address);
                break;

            case "mapeeprom":
                Kwp1281Wakeup();
                MapEeprom(_kwp1281);
                break;

            case "readeeprom":
                Kwp1281Wakeup();
                ReadEeprom(_kwp1281, address);
                break;

            case "readfaultcodes":
                Kwp1281Wakeup();
                ReadFaultCodes(_kwp1281);
                break;

            case "readident":
                Kwp1281Wakeup();
                ReadIdent(_kwp1281);
                break;

            case "readsoftwareversion":
                Kwp1281Wakeup();
                ReadSoftwareVersion(_kwp1281);
                break;

            case "reset":
                Kwp1281Wakeup();
                Reset(_kwp1281);
                break;

            case "setsoftwarecoding":
                Kwp1281Wakeup();
                SetSoftwareCoding(_kwp1281, softwareCoding, workshopCode);
                break;

            case "writeeeprom":
                Kwp1281Wakeup();
                WriteEeprom(_kwp1281, address, value);
                break;

            default:
                ShowUsage();
                break;
            }

            if (_kwp1281 != null)
            {
                _kwp1281.EndCommunication();
            }
        }