C# (CSharp) BRNBootDumper Dumper.Open Exemples

Exemple #1

        static void WriteUI()
        {
            #region User interface
            //show user interface
            SerialUserIF(out string port);
            UploadUserIF(out long targetAddress, out string filePath, out bool shouldVerify, out bool shouldVerboseLog);

            //print infos and make user confirm
            long fileSize = new FileInfo(filePath).Length;
            Console.Clear();
            Console.WriteLine($@"
Target Device: {port}

File: {filePath}
File Size: {fileSize}
Upload Target Address: 0x{ToHex(targetAddress)}
Upload End Address:    0x{ToHex(targetAddress + fileSize)}

Verify Data: {(shouldVerify ? "YES" : "NO")}
Verbose Log: {(shouldVerboseLog ? "YES" : "NO")}

Press <ENTER> to start write");
            Console.ReadLine();

            // double- confirm if any writes are outside of RAM
            if (targetAddress < BRNBootConstants.START_OF_RAM ||
                targetAddress > BRNBootConstants.END_OF_RAM ||
                fileSize > BRNBootConstants.RAM_SIZE)
            {
                Console.WriteLine($@"
!! WARNING !!
The Address you entered results in writes OUTSIDE of RAM
RAM Start: {ToHex(BRNBootConstants.START_OF_RAM)}
RAM End: {ToHex(BRNBootConstants.END_OF_RAM)}
RAM Size: {BRNBootConstants.RAM_SIZE}

Press <ENTER> 3x to write anyways");
                Console.ReadLine();
                Console.ReadLine();
                Console.ReadLine();
            }
            #endregion

            //initailize memory writer and connect
            Console.WriteLine("initialize writer");
            CrappyUpload up = new CrappyUpload
            {
                EnableDebugPrints = shouldVerboseLog
            };

            Console.WriteLine($"connecting to target device on {port}...");
            up.Open(port);

            // open file
            using (FileStream file = File.OpenRead(filePath))
            {
                // start upload timer
                Console.WriteLine("Start memory write...");
                Stopwatch sw = new Stopwatch();
                sw.Restart();

                // write to device
                up.Write(file, targetAddress);

                //stop timer and print time taken
                sw.Stop();
                up.Close();
                Console.WriteLine($"Finished writing to device after {Math.Floor(sw.Elapsed.TotalSeconds)} seconds");

                // verify what was actually written if enabled
                if (shouldVerify)
                {
                    // initialize dumper and connect
                    Console.WriteLine("Verifying written data...");
                    Dumper d = new Dumper
                    {
                        EnableDebugPrints = shouldVerboseLog
                    };

                    Console.WriteLine($"connecting to target device on {port}...");
                    d.Open(port);

                    // dump the memory
                    Console.WriteLine("Dumping memory...");
                    DumpTimed(d, targetAddress, targetAddress + fileSize, 10000, out MemoryStream verify);
                    d.Close();

                    // compare streams
                    if (CheckStreamsEqual(file, verify))
                    {
                        Console.WriteLine("Verification Success");
                    }
                    else
                    {
                        Console.WriteLine("!! Verification failed!");
                    }
                }
            }
        }

Exemple #2

        static void DumperUI()
        {
            #region user interface
            //show user interface
            SerialUserIF(out string port);
            DumperUserIF(out long startAddress, out long endAddress, out int blockSize, out bool shouldVerifyDump, out bool shouldVerboseLog);

            //print infos and make user confirm
            long dumpLenghtBytes = endAddress - startAddress;
            Console.Clear();
            Console.WriteLine($@"
Target Device: {port}

Will dump {dumpLenghtBytes} bytes
Start Address: 0x{ToHex(startAddress)}
End Address  : 0x{ToHex(endAddress)}
Block size   : {blockSize}

Dump verification is {(shouldVerifyDump ? "ON" : "OFF")}
Verbose logging is {(shouldVerboseLog ? "ON" : "OFF")}
Dumping will take {(dumpLenghtBytes / blockSize) * (shouldVerifyDump ? 2 : 1)} calls

Press <ENTER> to start dumping");
            Console.ReadLine();
            #endregion

            // initialize dumper and connect
            Console.WriteLine("initialize dumper...");
            Dumper d = new Dumper
            {
                EnableDebugPrints = shouldVerboseLog
            };

            Console.WriteLine($"connecting to target device on {port}...");
            d.Open(port);

            // dump the memory
            Console.WriteLine("Dumping memory...");
            DumpTimed(d, startAddress, endAddress, blockSize, out MemoryStream dump);

            // verification, if enabled
            if (shouldVerifyDump)
            {
                // dump memory a second time
                Console.WriteLine("Dumping memory, verification pass...");
                DumpTimed(d, startAddress, endAddress, blockSize, out MemoryStream verify);

                // check both dumps are equal, byte- by- byte
                if (!CheckStreamsEqual(dump, verify))
                {
                    Console.WriteLine("!! Dump verification failed!");
                }
            }

            // write dump to file
            Console.WriteLine("Writing dump to file...");
            Stopwatch sw = new Stopwatch();
            sw.Restart();

            // write to file
            using (MemoryStream source = dump)
                using (FileStream target = File.Create("dump.bin"))
                {
                    source.Seek(0, SeekOrigin.Begin);
                    source.CopyTo(target);
                }

            //stop timer and print time taken
            sw.Stop();
            Console.WriteLine($"Finished writing to file after {Math.Floor(sw.Elapsed.TotalSeconds)} seconds");
        }