Example #1
0
        public void ExportTo(IntelHexFile HexFile, Stream DestinationStream)
        {
            bool first = true;
            uint offset = 0;
            uint address = 0;
            foreach (IntelHexLine line in HexFile)
            {
                if (line is IntelHexDataLine)
                {
                    var dataLine = (IntelHexDataLine)line;
                    if (_trimStart && first)
                        offset = address + dataLine.Address;
                    first = false;

                    DestinationStream.Seek(address + dataLine.Address - offset, SeekOrigin.Begin);
                    dataLine.Data.Seek(0, SeekOrigin.Begin);
                    dataLine.Data.CopyTo(DestinationStream);
                }
                if (line is IntelHexExAddressLine)
                {
                    var addresLine = (IntelHexExAddressLine)line;
                    address = (uint)(addresLine.AddressExtension << 16);
                }
                if (line is IntelHexSegAddressLine)
                {
                    var addresLine = (IntelHexSegAddressLine)line;
                    address = addresLine.SegmentAddress;
                }
            }
        }
Example #2
0
        static int Main(string[] args)
        {
            if (args.Count() > 3 && args[0] == "--hex-merge")
            {
                Console.WriteLine("Hex Merge");

                IntelHexFile hexFile = null;

                for (int i = 1; i < args.Length - 1; i++)
                {
                    var currentFile = ConvertToFullPath(args[i]);

                    if (File.Exists(currentFile))
                    {
                        Console.WriteLine($"Merging: {currentFile}");

                        if (hexFile is null)
                        {
                            hexFile = IntelHexFile.CreateFrom(File.ReadAllText(currentFile));
                        }
                        else
                        {
                            var currentHexFile = IntelHexFile.CreateFrom(File.ReadAllText(currentFile));

                            hexFile.Records.Remove(hexFile.Records.Last());

                            hexFile.Records.AddRange(currentHexFile.Records);
                        }
                    }
                }

                File.WriteAllText(ConvertToFullPath(args[^ 1]), hexFile.ToString());
 public IntelHexFile Read(TextReader Reader)
 {
     var file = new IntelHexFile();
     string line;
     while ((line = Reader.ReadLine()) != null)
     {
         byte[] dat = GetBytes(line).ToArray();
         byte len = dat[0];
         var address = (ushort)(dat[1] << 8 | dat[2]);
         byte type = dat[3];
         byte checksum = dat.Last();
         byte[] data = dat.Skip(4).Take(dat.Length - 5).ToArray();
         switch (type)
         {
             case 0:
                 file.Add(new IntelHexDataLine(address, data));
                 break;
             case 1:
                 file.Add(new IntelHexEndLine());
                 break;
             case 2:
                 file.Add(new IntelHexSegAddressLine((uint)((data[0] << 8 | data[1]) << 4)));
                 break;
             case 4:
                 file.Add(new IntelHexExAddressLine((ushort)(data[0] << 8 | data[1])));
                 break;
         }
     }
     return file;
 }
Example #4
0
 private void tsbLoadHex_Click(object sender, EventArgs e)
 {
     if (ofd.ShowDialog() == DialogResult.OK)
     {
         _hexFile = new IntelHexFile(ofd.FileName);
         UpdateUI();
     }
 }
        public void SerializeDeserializeShouldBeTheSame(string testHexFile, long baseAddress)
        {
            var hexString = TestDataLoader.GetString(testHexFile);

            var intelHexFile  = IntelHexFile.CreateFrom(hexString, (int)baseAddress);
            var intelHexFile2 = IntelHexFile.CreateFrom(intelHexFile.BinaryData, (int)baseAddress);

            Assert.AreEqual(hexString, intelHexFile2.ToString());
        }
Example #6
0
        public void LoadNotSupportedTest()
        {
            string filename = "test.hex";

            File.WriteAllText(filename, IntelHexRecord.EncodeLine((eRecordType)8, 0x1000, null));

            IntelHexFile hf = new IntelHexFile();

            hf.Load(filename);
        }
Example #7
0
        public void LoadIgnoredLinerTest()
        {
            string filename = "test.hex";

            File.WriteAllText(filename, ":04000005000000CD2A");


            IntelHexFile hf = new IntelHexFile();

            hf.Load(filename);
        }
Example #8
0
        private void saveFileHex_Click(object sender, EventArgs e)
        {
            saveFileDialog.Filter           = "IntelHex Files|*.hex";
            saveFileDialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            saveFileDialog.FileName         = "NewHexFile";
            if (saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                var extension = Path.GetExtension(saveFileDialog.FileName);
                switch (extension)
                {
                case ".hex":
                    IntelHexFile.SaveAsIntelHex(saveFileDialog.FileName, hexf.Blocks.ToArray());
                    break;

                default:
                    MessageBox.Show("Unsupported file extention");
                    return;
                }
            }
        }
Example #9
0
        public void SaveAndLoadTest()
        {
            string filename = "test.hex";

            byte[]      newdata = new byte[1025];
            BinaryBlock bb      = new BinaryBlock(0x00010000 - 500);
            BinaryBlock bb1     = new BinaryBlock(0x00010000 - 50);

            bb.Append(newdata);
            bb1.Append(newdata);

            IntelHexFile.SaveAsIntelHex(filename, new BinaryBlock[] { bb, bb1 });

            IntelHexFile hf = new IntelHexFile();

            hf.Load(filename);

            Assert.AreEqual(2, hf.Blocks.Count);

            // Check binary black
            Assert.AreEqual(bb.Address, hf.Blocks[0].Address);
            Assert.AreEqual(bb.Length, hf.Blocks[0].Length);

            bb.UpdateHash(eHash.CRC32);
            Assert.AreEqual(bb.DisplayHash, hf.Blocks[0].DisplayHash);

            bb.UpdateHash(eHash.SHA256);
            Assert.AreNotEqual(bb.DisplayHash, hf.Blocks[0].DisplayHash);

            hf.UpdateHash(eHash.SHA256);
            Assert.AreEqual(bb.DisplayHash, hf.Blocks[0].DisplayHash);

            // append the same file again
            hf.Load(filename, eHash.CRC32, true);
            Assert.AreEqual(4, hf.Blocks.Count);
        }
Example #10
0
        private void exportToolStripMenuItem_Click(object sender, EventArgs e)
        {
            saveFileDialog.Filter           = "Binary Files|*.bin|IntelHex Files|*.hex";
            saveFileDialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            saveFileDialog.FileName         = hexf.Blocks[dataGridView.SelectedRows[0].Index].DisplayAddress;
            if (saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                var extension = Path.GetExtension(saveFileDialog.FileName);
                switch (extension)
                {
                case ".bin":
                    File.WriteAllBytes(saveFileDialog.FileName, hexf.Blocks[dataGridView.SelectedRows[0].Index].GetBytes());
                    break;

                case ".hex":
                    IntelHexFile.SaveAsIntelHex(saveFileDialog.FileName, new BinaryBlock[] { hexf.Blocks[dataGridView.SelectedRows[0].Index] });
                    break;

                default:
                    MessageBox.Show("Unsupported file extention");
                    return;
                }
            }
        }