private static FlashCRCData VerifyHexFile(byte[] hexfile) { // Here we want to find the right hex file. //TextReader tr = new StreamReader(FileName); // Read entire file into a buffer, and remove all the colons. string HexFile = Encoding.UTF8.GetString(hexfile, 0, hexfile.Length);/*tr.ReadToEnd();*/ //tr.Close(); string[] HexFileLines = HexFile.Split(':'); HexLine[] hexLines = new HexLine[HexFileLines.Length]; int i = 0; foreach (string HexLineString in HexFileLines) { if (HexLineString.Length > 5 && !HexLineString.Equals("00000001FF\r\n")) { //Convert into numeric hexLines[i].RecDataLen = Convert.ToByte(HexLineString.Substring(0, 2), 16); hexLines[i].Address = Convert.ToUInt32(HexLineString.Substring(2, 4), 16); hexLines[i].RecType = Convert.ToByte(HexLineString.Substring(6, 2), 16); hexLines[i].Data = StringToByteArray(HexLineString.Substring(8, hexLines[i].RecDataLen * 2)); hexLines[i].Checksum = Convert.ToByte(HexLineString.Substring(8 + hexLines[i].RecDataLen * 2, 2), 16); //Calculate the virtual Flash Space. i++; } } hexLines = hexLines.Take(i).ToArray(); return(VerifyFlash(hexLines)); }
private HexLine ParseLine(string line) { line = line.Trim(); if (line[0] != ':') { throw new HexFileException("No leading ':' in row"); } //remove the ":" from the record line = line.Substring(1, (line.Length - 1)); // Validate checksum if (!ValidateChecksum(line)) { throw new HexFileException("Invalid checksum"); } HexLine hexLine = new HexLine(); hexLine.recordLength = Convert.ToByte(line.Substring(0, 2), 16); hexLine.addressField = Convert.ToUInt16(line.Substring(2, 4), 16); hexLine.recordType = (HexRecordType)Convert.ToByte(line.Substring(6, 2), 16); hexLine.dataPayload = line.Substring(8, hexLine.recordLength * 2); return(hexLine); }
private void ProcessLine(string line) { HexLine hexLine = HexLine.Parse(line); Address baseAddress = 0x000000; //always 0, not used currently switch (hexLine.RecordType) { case RecordType.Data: List <Word> words = hexLine.Data.ToLittleEndians(); //Reading little endian data Address byteAddress = (Address)(baseAddress + hexLine.Address); //not used. correcting address if it is Extended Address Address wordAddress = (Address)(byteAddress >> 1); //Byte to Word address blocks.Add(new MemoryBlock(wordAddress, words)); break; case RecordType.EndOfFile: MergeBlocks(); break; case RecordType.ExtendedSegmentAddress: //baseAddress = ((Address)hexLine.Data.ReadBigEndianWord(0)) << 4; //break; case RecordType.ExtendedLinearAddress: //baseAddress = ((Address)hexLine.Data.ReadBigEndianWord(0)) << 16; //break; case RecordType.StartSegmentAddress: case RecordType.StartLinearAddress: throw new NotSupportedException(); default: throw new Exception($"Unknown {nameof(RecordType)} {hexLine.RecordType:X}"); } }
void createMap(){ hexLines = new HexLine[height]; for (int i = 0; i < height; i ++) { hexLines[i] = new HexLine(); hexLines[i].columns = new HexInfo[width]; } for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { float xPos = x * xOffset; if (y % 2 == 1) { xPos += xOffset/2; } //Instantiate hex GameObject Hex_go; if (x >= 3) Hex_go = (GameObject)Instantiate (hexprefab3, new Vector3 (xPos, 0, y * zOffset), Quaternion.identity); else Hex_go = (GameObject)Instantiate (hexprefab1, new Vector3 (xPos, 0, y * zOffset), Quaternion.identity); HexInfo hexInfo = Hex_go.GetComponentInChildren<HexInfo> (); hexInfo.x = x; hexInfo.y = y; hexInfo.Nucli = false; hexInfo.ColorDensity = 0; hexInfo.Clickable = true; hexInfo.map = this; hexInfo.HexColor = 'W'; hexLines [y].columns [x] = hexInfo; //Rename hexes with coordenate names Hex_go.name = "Hex_" + x + "_" + y; //Group hexes in a GameObject parent called "Hex" Hex_go.transform.SetParent (this.transform); Hex_go.isStatic = true; if (x < 3) hexInfo.Clickable = false; } } }
//public Color defaultColor = Color.white; void Awake() { new Setting(); gridCanvas = GetComponentInChildren <Canvas>(); hexMesh = GetComponentInChildren <HexMesh>(); lineRenderer = GetComponentInChildren <HexLine>(); width = Setting.GetWidth(); height = Setting.GetHeight(); cells = new HexCell[height * width]; for (int z = 0, i = 0; z < height; z++) { for (int x = 0; x < width; x++) { CreateCell(x, z, i++); } } }
public static HexLine Parse(string line) { if (line[0] != ':') { throw new FormatException("Must start with colon ':'"); } if ((line.Length - 1) % 2 != 0) { throw new FormatException("Line length must be even (excluding colon ':'"); } var bytes = ReadAllBytes(line); var hexLine = new HexLine(); hexLine.Checksum = bytes.Last(); Byte calculatedChecksum = (Byte)(~bytes.DropLast().Sum(_ => _) + 1); if (hexLine.Checksum != calculatedChecksum) { throw new ArgumentException("Checksum does not match"); } hexLine.RecordType = (RecordType)(bytes[3]); hexLine.Address = (Address)bytes.ReadBigEndianWord(1); hexLine.ByteCount = bytes[0]; if (hexLine.ByteCount != bytes.Count - 5) { throw new ArgumentException("Checksum is correct but has less/more data"); } if (hexLine.ByteCount != 0) { hexLine.Data = bytes.GetRange(4, hexLine.ByteCount); } return(hexLine); }
public bool Parse(string fn, int maxBlockSize = 256) { var ret = false; try { using (var reader = File.OpenText(fn)) { string line; UInt32 addrPrefix = 0; while ((line = reader.ReadLine()) != null) { HexLine hexLine = new HexLine(); if (!hexLine.Parse(line)) { return(false); } if (hexLine.Type == HexLine.HexLineType.ExtendedLinearAddress) { addrPrefix = hexLine.Addr << 16; } else if (hexLine.Type == HexLine.HexLineType.StartLinearAddress) { EntryPoint = hexLine.Addr; } else if (hexLine.Type == HexLine.HexLineType.EndOfFile) { ret = true; break; } else if (hexLine.Type == HexLine.HexLineType.Data) { var addr = addrPrefix | hexLine.Addr; MemoryBlock block = null; try { block = Blocks.Find(v => v.StartAddr < addr && v.StartAddr + v.Length == addr && v.Length + hexLine.Content.Length <= maxBlockSize); } catch (Exception) { // ignore } if (block == null) { block = new MemoryBlock(); block.StartAddr = addr; Blocks.Add(block); } block.Content.AddRange(hexLine.Content); } } } } catch (Exception) { // ignore } return(ret); }
private static FlashCRCData VerifyFlash(HexLine[] hexLines) { uint ProgLen; uint VirtualFlashAdrs; uint ProgAddress; // 5 MB Virtual Flash. byte[] VirtualFlash = new byte[5 * 1024 * 1024]; for (int i = 0; i < 5 * 1024 * 1024; i++) // initialize virtual flash to all FFs { VirtualFlash[i] = 0xFF; } uint ExtLinAddress = 0; uint ExtSegAddress = 0; uint MaxAddress = 0; uint MinAddress = 0xFFFFFFFF; // Reset max address and min address. for (int i = 0; i < hexLines.Length; i++) { HexLine HexRecordSt = hexLines[i]; switch (HexRecordSt.RecType) { case 0: //Record Type 00, data record.\ //Dont need the following line since we have extacted this data elsewhere. //HexRecordSt.Address = (((HexRec[1] << 8) & 0x0000FF00) | (HexRec[2] & 0x000000FF)) & (0x0000FFFF); HexRecordSt.Address = HexRecordSt.Address + ExtLinAddress + ExtSegAddress; ProgAddress = (HexRecordSt.Address | 0x80000000); if (ProgAddress < 0x9FC00000) // Make sure we are not writing boot sector. { if (MaxAddress < (ProgAddress + HexRecordSt.RecDataLen)) { MaxAddress = ProgAddress + HexRecordSt.RecDataLen; } if (MinAddress > ProgAddress) { MinAddress = ProgAddress; } VirtualFlashAdrs = (ProgAddress - 0x9D000000); // Program address to local virtual flash address foreach (byte CurrData in HexRecordSt.Data) { VirtualFlash[VirtualFlashAdrs++] = CurrData; } //memcpy((void *)&VirtualFlash[VirtualFlashAdrs], HexRecordSt.Data, HexRecordSt.RecDataLen); } break; case 02: // Record Type 02, defines 4 to 19 of the data address. ExtSegAddress = (((uint)HexRecordSt.Data[0] << 16) & 0x00FF0000u) | (((uint)HexRecordSt.Data[1] << 8) & 0x0000FF00u); ExtLinAddress = 0; break; case 04: ExtLinAddress = (((uint)HexRecordSt.Data[0] << 24) & 0xFF000000) | (((uint)HexRecordSt.Data[1] << 16) & 0x00FF0000); ExtSegAddress = 0; break; case 01: //Record Type 01 default: ExtSegAddress = 0; ExtLinAddress = 0; break; } } MinAddress -= MinAddress % 4; MaxAddress += MaxAddress % 4; ProgLen = MaxAddress - MinAddress; //StartAdress = HexRecordSt.MinAddress; VirtualFlashAdrs = (MinAddress - 0x9D000000); //*crc = CalculateCrc((char*)&VirtualFlash[VirtualFlashAdrs], *); byte[] Temp = VirtualFlash.Skip((int)VirtualFlashAdrs).Take((int)ProgLen).ToArray(); // array of flash memory to be programmed byte[] Temp2 = VirtualFlash.Skip((int)0x1000).Take((int)0x2FC).Concat(VirtualFlash.Skip((int)0x1348).Take((int)0x7DCB8)).ToArray(); return(new FlashCRCData { CRC = CalculateCrc(Temp, (int)ProgLen), Length = ProgLen, StartAddress = MinAddress, flashMD5 = GetMd5Hash(Temp2) }); }
private HexLine ParseLine(string line) { line = line.Trim(); if (line[0] != ':') throw new HexFileException("No leading ':' in row"); //remove the ":" from the record line = line.Substring(1, (line.Length - 1)); // Validate checksum if (!ValidateChecksum(line)) throw new HexFileException("Invalid checksum"); HexLine hexLine = new HexLine(); hexLine.recordLength = Convert.ToByte(line.Substring(0, 2), 16); hexLine.addressField = Convert.ToUInt16(line.Substring(2, 4), 16); hexLine.recordType = (HexRecordType)Convert.ToByte(line.Substring(6, 2), 16); hexLine.dataPayload = line.Substring(8, hexLine.recordLength * 2); return hexLine; }
private void LoadFromStream(Stream stream) { blocks = new List <MemoryBlock>(); string line; bool hexFileEOF = false; var currentBlock = new MemoryBlock(); UInt64 currentExtendedAddress = 0; Size = 0; using (var reader = new StreamReader(stream)) { while (((line = reader.ReadLine()) != "") && (hexFileEOF == false)) { HexLine hexLine = ParseLine(line); switch (hexLine.recordType) { case HexRecordType.EOF: hexFileEOF = true; break; case HexRecordType.ExtendedLinearAddress: currentExtendedAddress = Convert.ToUInt64(hexLine.dataPayload, 16) << 16; // Add a new memory block section if // 1: the current block has data (size > 0) // 2: the next block has a different starting address to the current block // 3: the next block address does not already exist in the array. if ((currentBlock.size > 0) && (currentExtendedAddress != currentBlock.startAddress) && (blocks.Count(b => b.startAddress == currentExtendedAddress) == 0)) { blocks.Add(currentBlock); currentBlock = new MemoryBlock(currentExtendedAddress); } break; case HexRecordType.Data: // Calculate the maximum possible address using the given data // Actual maximum is 65536 bytes (2^16). UInt64 size = (ulong)hexLine.recordLength + (ulong)hexLine.addressField; if (size > currentBlock.size) { currentBlock.size = size; } // Assuming each memory block is 65K in size, // load the data buffer with data at the given address uint offset = 0; for (byte j = 0; j < hexLine.recordLength; j++) { uint addr = (uint)hexLine.addressField + j - offset; // Address exceeds the currently allocated data block, // create a new block at the current address if (addr >= currentBlock.data.Length) //65536 { // Limit the block size currentBlock.size = (uint)currentBlock.data.Length; // Split the memory block blocks.Add(currentBlock); currentBlock = new MemoryBlock(addr + currentExtendedAddress); // Wrap the address around into the new block offset = (uint)currentBlock.data.Length; addr -= offset; } currentBlock.data[addr] = Convert.ToByte(hexLine.dataPayload.Substring(j * 2, 2), 16); } // Note that if a data line is missing, the data bytes are simply left as '0' //TODO: are they supposed to be set to 0xFF? break; default: throw new HexFileException(String.Format("Unsupported hex record type '{0}'", hexLine.recordType.ToString())); } } } // Finally add the last block used blocks.Add(currentBlock); Size = 0; foreach (var block in blocks) { Size += block.size; } /*Console.WriteLine("Num blocks: {0}", blocks.Count); * * UInt64 totalSize = 0; * foreach (var block in blocks) * { * //Console.WriteLine("{2}\n\tstartAddress:{0}\n\tsize:{1}", block.startAddress, block.size, block.ToString()); * Console.WriteLine(block); * totalSize += block.size; * } * Console.WriteLine("Total size:{0} bytes", totalSize);*/ }