Hex文件解析

 Hex文件每一行数据全部由十六进制数字组成，包含 ：、数据长度、起始地址、记录类型、数据、校验和六个部分。

上图中，每一行记录都以“：”开头，“20”为后面的数据长度，表示该记录有32字节的数据，“C240”为该行记录的起始地址中的低位，后面的“00”为该记录的类型，

“0060FAE83132333435363738393000000060C2000060FFF7000900020060FFF8”为该记录所包含的全部32字节数据，“B5”为校验和，

此行就是将数据依次刷写到起始地址为“0060C240”的连续地址中，后面会解释“0060”的由来。

每字节数据被编码成2个16进制字符，第一个字符代表数据的高四位，第二个字符代表数据的低4位。

 

1. 记录类型

Hex文件记录类型包括00、01、02、03、04、05等，每一种都包含不同的含义

00：数据记录

01：文件结束记录

02：扩展段地址记录

03：开始段地址记录

04：扩展线性地址记录

05：开始线性地址记录

上图中截取了三种记录类型04、00和01

第一行中数据长度为02，表示两字节的数据“095B”，04位扩展线性数据记录，扩展地址就是04记录中的数据位“095B”,

该地址就作为一下每行的起始地址中的高位，第二行记录中的地址“0000”为低位，那么第二行记录的起始地址就是“095B0000”，

第三行记录的起始地址就是“095B0020”，“095B”会一直作为高位，直到下一个扩展线性记录的出现，

最后一行为文件记录的结束

 

2. 起始地址

起始地址一般由高位和低位组成，即04记录中的地址加上00记录中的地址

 

3. 数据长度

包含一个字节，即后面数据的字节数的十六进制表示

 

4.校验和

包含一个字节，校验和=0xFF&(0x100-(长度字节+地址字节+类型字节+数据字节))

 

 

长度字节+地址字节+类型字节+数据字节=0x20+0x00+0x00+0x00+0x00+...+0xC3+0xC3=0x1880

0x80=0xFF&(0x100-0x1880)

 

5.实现代码

public class Hex
    {
        public string path;                                                        //选择文件的路径
        public List<List<string>> listAllline = new List<List<string>>();          //依据区域对数据进行存储，一个扩展性地址放一个list中，存储含有部分记录的Hex文件包括（00、04和01的记录等）


        /// <summary>
        /// 读取Hex文件，将所有记录存储在List中，便于调用修改
        /// </summary>
        /// <param name="file_path"></param>
        /// <returns></returns>
        public bool Read_Hex(string file_path)
        {
            FileStream fileStream = null ;
            StreamReader streamReader = null;
            int count = 0;
            string type;
            int regionNum = -1;
            try
            {
                fileStream = new FileStream(file_path, FileMode.Open, FileAccess.Read);
                streamReader = new StreamReader(fileStream, Encoding.Default );
                string currentLine = "";
                listAllline.Clear();

                while ((currentLine = streamReader.ReadLine()) != null && currentLine.Trim ()!="")
                {
                    if(currentLine.Substring(0, 1)==":")
                    {
                        type = currentLine.Substring(7, 2);
                        if (type == "04" || type == "01")
                        {
                            regionNum++;
                            listAllline.Add(new List<string>());
                        }
                        count++;
                        listAllline[regionNum].Add(currentLine);
                    }

                }
                Console.WriteLine("文件中共有" + count + "行数据");                
                Console.WriteLine( regionNum  + "块区域");
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString() + count);
                MessageBox.Show(ex.Message +count.ToString());
                return false;
            }
            finally
            {
                fileStream.Close();
                streamReader.Close();
            }

        }

        /// <summary>
        /// 计算一行数据的校验和
        /// </summary>
        /// <param name="line">包含：的整行记录 </param>
        /// <returns></returns>
        private string Checksum(string line)
        {
            string checkSum ;
            int sum = 0;
            string[] byteNum = new string[line.Length / 2 ];//计算字节数
            for (int i = 1; i < line.Length / 2 ; i++)
            {
                byteNum[i] = line.Substring(i * 2 + 1, 2);//从长度位将一行数据按照字节分割为字节数组，注意前面的：
                sum += Convert.ToInt32(byteNum[i], 16);//将数据进行累加
            }
            checkSum = Convert.ToString(0xFF & (0x100-sum), 16); //计算校验位
            return checkSum;
        }

        /// <summary>
        /// 将区域内不连续的地址补全
        /// </summary>
        /// <param name="completeValue">用于补全的字符</param>
        /// <returns></returns>
        public List<List<string>> CompleteFile(string completeValue)
        {
            List<List<string>> listTemp = new List<List<string>>();//暂存数据
            List<List<string>> listCompletion = new List<List<string>>();//用来存储补全后的数据
            uint currentAdd = 0;
            uint dataLength = 0;
            uint lastDataLength = 0;                                 //上一行数据长度
            uint lastAdd = 0;                                        //上一行地址
            int completeLine = 0;                                    //计算区域补全的行数
            int totalComplete = 0;                                   //计算总补全的行数
            string lastLine=string.Empty  ;                          //上一行的记录
            string currentLine;

            try
            {
                #region 将地址相同高位的记录放入一个list中
                int a = -1;
                for (int i = 0; i < listAllline.Count; i++)
                {
                    a++;
                    listTemp.Add(new List<string>());
                    string firstLine = listAllline[i][0];
                    for (int k = 0; k < listAllline[i].Count; k++)
                    {
                        listTemp[a].Add(listAllline[i][k]);
                    }
                    for (int j = i+1; j < listAllline.Count; j++)
                    {
                        if (firstLine == listAllline[j][0])
                        {
                            for (int k = 1; k < listAllline[j].Count; k++)
                            {
                                listTemp[a].Add(listAllline[j][k]);
                            }
                            i++;
                        }
                    }
                }
                #endregion
                StringBuilder temp = new StringBuilder();
                for (int i = 0; i < listTemp.Count; i++)
                {
                    completeLine = 0;
                    listCompletion.Add(new List<string>());
                    for (int j = 0; j < listTemp[i].Count; j++)
                    {
                        currentLine = listTemp[i][j];
                        if (j == 0)
                        {
                            listCompletion[i].Add(currentLine);
                            continue;
                        }
                        if (j == 1)
                        {
                            if(currentLine.Substring(3, 4)=="0000")//第一行的地址低位就是0000
                            {
                                listCompletion[i].Add(currentLine);
                                lastLine = currentLine;
                                lastDataLength = Convert.ToUInt32(currentLine.Substring(1, 2), 16);
                                lastAdd = Convert.ToUInt32(currentLine.Substring(3, 4), 16);
                                continue;
                            }
                            else        //第一行的地址低位不是0000，从头开始做补全
                            {
                                temp.Clear();
                                completeLine++;
                                temp.Clear();
                                temp.Append(currentLine.Substring(0, 3));
                                string newAdd_string = "0000";
                                temp.Append(newAdd_string);
                                for (int k = 0; k < Convert.ToInt32(currentLine.Substring(1, 2),16); k++)
                                {
                                    temp.Append(completeValue);
                                }
                                temp.Append(Checksum(temp.ToString()));
                                listCompletion[i].Add(temp.ToString());

                                lastLine = temp.ToString ();
                                lastDataLength = Convert.ToUInt32(lastLine.Substring(1, 2), 16);
                                lastAdd = Convert.ToUInt32(lastLine.Substring(3, 4), 16);
                            }
                        }                        

                        dataLength = Convert.ToUInt32(currentLine.Substring(1, 2), 16);
                        currentAdd = Convert.ToUInt32(currentLine.Substring(3, 4), 16);

                        if (lastAdd + lastDataLength < currentAdd)          //判断相邻记录地址是否连续
                        {
                            int completeLen = Convert.ToInt32(currentAdd - lastAdd - lastDataLength);    //计算需要补全的长度
                            uint newAdd = lastAdd;                                      //每行新记录填补的地址
                            temp.Clear();
                            while (completeLen > 0)
                            {
                                if (completeLen <= lastDataLength)               //需要补的数据长度不足上一行记录的数据长度
                                {
                                    completeLine++;
                                    temp.Clear();
                                    temp.Append(":");
                                    string newLen = Convert.ToString(completeLen, 16).PadLeft(2, '0').ToUpper();
                                    temp.Append(newLen);
                                    string newAdd_string = Convert.ToString(newAdd + completeLen, 16).PadLeft(4, '0').ToUpper();
                                    temp.Append(newAdd_string);
                                    for (int k = 0; k < completeLen; k++)
                                    {
                                        temp.Append(completeValue);
                                    }
                                    temp.Append(Checksum(temp.ToString()));
                                    listCompletion[i].Add(temp.ToString());
                                    completeLen -= completeLen;                  //减去已补过的长度
                                }
                                else
                                {
                                    completeLine++;
                                    temp.Clear();
                                    temp.Append(lastLine.Substring(0, 3));
                                    string newAdd_string = Convert.ToString(newAdd + lastDataLength, 16).PadLeft(4, '0').ToUpper();
                                    temp.Append(newAdd_string);
                                    for (int k = 0; k < Convert.ToInt32(lastDataLength); k++)
                                    {
                                        temp.Append(completeValue);
                                    }
                                    temp.Append(Checksum(temp.ToString()));
                                    listCompletion[i].Add(temp.ToString());
                                    completeLen -= Convert.ToInt32(lastDataLength);
                                }
                                newAdd = newAdd + lastDataLength;
                            }

                            currentAdd = newAdd + lastDataLength;                               //当前行的地址
                            listCompletion[i].Add(currentLine);
                        }
                        else
                        {
                            listCompletion[i].Add(currentLine);                        
                        }
                        lastAdd = currentAdd;                                            //记录上一行地址
                        lastDataLength = dataLength;                                     //记录上一行数据长度
                        lastLine = currentLine;

                        if (j == listTemp[i].Count-1)                                 //判断是否到这个list的最后一行   
                        {
                            if ((j+ completeLine) < 2048)                             //一个区域最多有2048行记录，
                            {
                                temp.Clear();
                                uint newAdd = lastAdd;
                                while ((j + completeLine) < 2048)                     //开始末尾补全
                                {
                                    completeLine++;
                                    temp.Clear();
                                    temp.Append(lastLine.Substring(0, 3));
                                    string newAdd_string = Convert.ToString(newAdd + lastDataLength, 16).PadLeft(4, '0').ToUpper();
                                    temp.Append(newAdd_string);
                                    for (int k = 0; k < Convert.ToInt32(lastDataLength); k++)
                                    {
                                        temp.Append(completeValue);
                                    }
                                    temp.Append(Checksum(temp.ToString()));
                                    listCompletion[i].Add(temp.ToString());
                                    newAdd = newAdd + lastDataLength;
                                    
                                }
                            }                         
                        }
                    }
                    totalComplete += completeLine;
                }

                Console.WriteLine("共补全了" + totalComplete + "行");
                return listCompletion;
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message );
                MessageBox.Show(ex.ToString ());
                return null;
            }
            
        }

        /// <summary>
        /// 检查每行记录数据是否有缺失,是否完整
        /// </summary>
        /// <returns></returns>
        public bool CompleteCheck(string line)
        {
            string type = line.Substring(7,2);
            string length = line.Substring(1,2);
            string address = line.Substring(3,4);
            return line.Length == 1 + 2 + 4 + 2 + Convert.ToInt32(length) * 2 + 2 ? true : false;
        }

        /// <summary>
        /// 依据地址和数据修改Hex文件
        /// </summary>
        /// <param name="startAdd"></param>
        /// <param name="modifyStr"></param>
        /// <returns></returns>
        public bool Modify_hex(string startAdd, string modifyStr)
        {
            try
            {
                List<int> goalRegionList = new List<int>();            //存储具有地址高位的记录区域
                int modifyLen = modifyStr.Length;                      //修改的数据长度，判断修改是否完成
                string add_High = startAdd.Substring(0, 4);
                string add_Low = startAdd.Substring(4, 4);
                for (int i = 0; i < listAllline.Count; i++)
                {
                    if (add_High == listAllline[i][0])
                    {
                        goalRegionList.Add(i);
                    }
                }

                uint add_Low_uint = Convert.ToUInt32(add_Low, 16);
                string currentLine = string.Empty;
                uint currentAdd_Low_unit;
                for (int k = 0; k < goalRegionList.Count; k++)
                {
                    for (int i = 1; i < listAllline[goalRegionList[k]].Count; i++)
                    {
                        currentLine = listAllline[goalRegionList[k]][i];
                        if (currentLine.Length <= 11)                       //跳过01的记录
                        {
                            continue;
                        }
                        currentAdd_Low_unit = Convert.ToUInt32(currentLine.Substring(3, 4), 16);
                        if (add_Low_uint >= currentAdd_Low_unit && Convert.ToUInt32(add_Low_uint - currentAdd_Low_unit) < Convert.ToUInt32(currentLine.Substring(1, 2), 16))//找到需要修改的数据的起始地址所在行
                        {
                            while (modifyLen > 0)
                            {
                                currentAdd_Low_unit = Convert.ToUInt32(currentLine.Substring(3, 4), 16);
                                int differenceAdd = Convert.ToInt32(add_Low_uint - currentAdd_Low_unit);          //一行中需修改的起始地址之前的数据地址
                                int modifyAdd = Convert.ToInt32(currentLine.Substring(3, 4), 16) * 2 - differenceAdd * 2;//每行中需要修改的数据长度

                                if (Convert.ToInt32(currentLine.Substring(3, 4), 16) - differenceAdd >= modifyLen / 2)//判断需要修改的数据地址是不是在同一行
                                {
                                    string str1 = currentLine.Remove(9 + (differenceAdd) * 2, modifyLen);//从修改的起始地址位置开始移除旧数据，长度为需要修改的数据长度，12 = 类型2字符+长度2字符+地址8字符
                                    string str2 = str1.Insert(9 + (differenceAdd) * 2, modifyStr);//将新数据插入当前记录行
                                    string sum_string = Checksum(str2.Remove(str2.Length - 2));//计算新的校验位字节
                                    currentLine = str2.Remove(str2.Length - 2, 2) + sum_string;//移除旧校验位，加入新校验位
                                    modifyLen = modifyLen - modifyAdd;//正常情况下，修改的数据地址在同一行，此时计算之后modifyLen=0，跳出循环
                                }
                                else                 //地址不在同一行
                                {
                                    string str1 = currentLine.Remove(9 + (differenceAdd) * 2, Convert.ToInt32(currentLine.Substring(1, 2), 16) * 2 - differenceAdd * 2);//移除地址后面的所有数据和校验位
                                    string str2 = str1.Insert(9 + (differenceAdd) * 2, modifyStr.Substring(0, (Convert.ToInt32(currentLine.Substring(1, 2), 16) - (differenceAdd)) * 2));//加入新数据
                                    string sum_string = Checksum(str2.Remove(str2.Length - 2));
                                    currentLine = str2.Remove(str2.Length - 2, 2) + sum_string;
                                    modifyLen = modifyLen - modifyAdd;//计算剩余需要修改的数据长度
                                    modifyStr = modifyStr.Remove(0, modifyAdd);//移除已经修改的数据
                                    startAdd = startAdd + (Convert.ToUInt32(currentLine.Substring(1, 2), 16) - Convert.ToUInt32(differenceAdd));//计算剩余数据的起始地址
                                }
                            }
                        }
                    }
                }
                
                return true;
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 生成新的Hex文件
        /// </summary>
        /// <param name="newFilepath"></param>
        /// <returns></returns>
        public bool Write_Hex(string newFilepath)
        {
            StreamWriter Stream_Writer = null;
            try
            {
                Stream_Writer = new StreamWriter(newFilepath + ".hex", false);
                for (int i = 0; i < listAllline.Count; i++)
                {
                    for (int j = 0; j < listAllline[i].Count; j++)
                    {
                        Stream_Writer.WriteLine(listAllline[i][j]);
                    }
                }
                return true;
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message );
                return false;
            }
            finally
            {
                Stream_Writer.Close();
            }
        }

 

如有错误，欢迎指正