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();
            }
        }

 

如有錯誤，歡迎指正