HEX文件格式解析（转）

清疚 2024-04-17 20:28 90阅读 0赞

Hex格式文件有两种，一种是Intel的Intel HEX，另一种是Motorola（摩托罗拉）的SREC（又称MOT）。

--------------------

Intel HEX 文件是由一行行符合Intel HEX 文件格式的文本所 构 成的ASCII 文本文件。在Intel HEX 文件中，每一行包含一 个 HEX 记录 。 这 些 记录 由 对应 机器 语 言 码 和/ 或常量 数 据的十六 进 制 编码数 字 组 成。Intel HEX 文件通常用于 传输将 被存于ROM 或者EPROM 中的程序和 数 据。大多 数 EPROM 编 程器或模 拟器使用Intel HEX 文件。

Hex文件是可以烧写到单片机中，被单片机执行的一种文件格式，生成Hex文件的方式由很多种，可以通过不同的编译器将C程序或者汇编程序编译生成hex。

一般Hex文件通过记事本就可以打开。可以发现一般Hex文件的记录格式如下：

![在这里插入图片描述][2019083116155586.png]

Intel HEX 由任意数量的十六 进 制 记录组 成。每 个记录 包含5 个 域， 它们按以下格式排列：

每一组字母 对应 一 个 不同的域，每一 个 字母 对应 一 个 十六 进 制 编码 的 数 字。每一 个 域由至少 两个 十六 进制 编码数 字 组 成， 它们构 成一 个 字 节 ，就像以下描述的那 样：

（1）：(冒号)每个Intel HEX 记录 都由冒 号开头 ；

（2）LL 是 数 据 长 度域, 它 代表 记录当 中 数 据字 节 (dd) 的 数量 ；

（3）aaaa 是地址域, 它代表 记录当 中 数据的起始地址；

（4）TT是代表HEX 记录类 型的域 , 它 可能是以下 数 据 当 中的一 个：  
00 – 数 据 记录（Data Record）  
01 – 文件结 束 记录（End of FileRecord）  
02 – 扩展段地址 记录（ExtendedSegment Address Record）  
03 – 开始段地址 记录（Start Segment Address Record）  
04 – 扩展 线 性地址 记录（Extended Linear Address Record）  
05 – 开始线性地址 记录（Extended Segment Address Record）

（5）dd 是数 据域 , 它 代表一 个 字 节 的 数 据. 一 个记录 可以有 许 多 数 据字 节 . 记录当 中 数 据字 节 的 数 量必 须 和数 据 长 度域(ll) 中指定的 数字相符.

（6）cc 是校验 和域 , 它 表示 这个记录 的校 验 和. 校 验 和的 计 算是通 过将记录当 中所有十六 进 制 编码数 字 对 的 值相加, 以256 为 模 进 行以下 补 足.

表示为：“：\[1字节长度\]\[2字节地址\]\[1字节记录类型\]\[n字节数据段\]\[1字节校验和\] ”

--------------------

（TT）具体根据记录类型分析如下：

(1)数据记录”00”

Intel HEX文件由任意数 量以回车换行符结束的数据记录组成数据记录外观如下:  
:10246200464C5549442050524F46494C4500464C33  
其中:10 是这个记录当中 数 据字 节 的 数量.即0x10 ；  
2462 是数据 将 被下 载 到存 储 器 当中的地址.即0x2462 ；

00 是记录类型( 数 据 记录).即0x00 ；  
464C…464C是 数据.分别代表0x46,0x4C… ；  
33 是这个记录的校 验和即0x33；计算方法如下：256D-(10H+24H+62H+00H+46H+4CH+55H+49H+44H+20H+50H+52H+4FH+46H+49H+4CH+45H+00H+46H+4CH)/100H=33H；

(2)文件结束(EOF)”01”

Intel HEX文件必须以文件结束(EOF) 记录结束这个记录的记录类的值必须是01.EOF 记录 外 观总是如下:  
:00000001FF  
其中:00 是记录当中 数 据字 节 的 数量.  
0000 是数据被下载到存储器当中的地址. 在文件结束记录当中地址是没有意义，被忽略的.0000h 是典型的地址；  
01 是记录类型 01( 文件 结 束 记录)  
FF 是 这个记录 的校 验 和, 计算方法如下: 256D-（00H+00H+00H+01H）=FFH；

(3)扩展线性地址记录(HEX386) ”04”

由于每行标识数据地址的只有2Byte，所以最大只能到64K，为了可以保存高地址的数据，就有了Extended Linear AddressRecord。如果这行的数据类型是0x04，那么，这行的数据就是随后数据的基地址。

扩展线性地址记录也叫作32位地址记录或HEX386记录.这些记录含数据的高16位扩展线性地址记录总是有两个数据字节，外观如下：  
:02000004FFFFFC

其中:02 是这个记录当中 数 据字 节 的 数量.  
0000 是地址域, 对于 扩 展 线 性地址 记录 , 这个 域 总是0000.  
04 是记录类型 04( 扩 展 线 性地址 记录)  
FFFF 是地址的高16 位.  
FC 是这个记录的校 验 和, 计算如下: 256D-（02H+00H+00H+04H+FFH+FFH）/100H=FCH；

当一 个扩展 线 性地址记录被读 取, 存 储于数据域的扩展线性地址被保存，它被应于

从 Intel HEX 文件 读取 来 的 随 后的 记录 . 线 性地址保持有效, 到 它 被另外一 个扩址记录 所改 变。

通 过 把 记录当 中的地址域 与 被移位的 来 自 扩 展 线 性地址 记录 的地址 数 据相加

获 得 数 据 记录 的 绝对 存 储器地址。

以下的例子演示了这个过 程:

:0200000480007A //数据记录的绝对存储器地址高16位为0x8000

:100000001D000A00000000000000000000000000C9

:100010000000000085F170706F0104005D00BD00FC

第一行，是Extended Linear Address Record，里面的数据，也就是基地址是0x8000，第二行是DataRecord，里面的地址值是0x0000。那么数据1D000A00000000000000000000000000（共16个字节）要写入FLASH中的地址为 (0x8000<< 16)| 0x0000，也就是写入FLASH的0x80000000这个地址；第三行的数据写入地址为0x80000010.当一个HEX文件的数据超过64k的时候，文件中就会出现多个Extended Linear Address Record。

(4)扩展段地址记录(HEX86)“02“

扩展段地址记录也叫HEX86 记录 , 它包括4-19 位数据地址段. 扩展段地址记总是有两

个数 据字节 , 外观如下:  
:020000021200EA  
其中:02 是记录当中 数 据字 节 的 数量；  
0000 是地址域. 对于 扩 展段地址 记录 , 这个 域 总是0000；  
02 是记录类型 02( 扩 展段地址 记录)；  
1200 是地址段；  
EA 是这个记录的校 验 和；

当一 个扩 展段地址 记录 被 读 取, 存 储 于 数 据域的 扩 展段地址被保存, 它 被 应 用于 从 Intel HEX 文件 读 取 来的 随 后的 记录 . 段地址保持有效, 直到 它 被另外一 个扩 展地址 记录 所改 变。

通 过 把 记录当 中的地址域 与 被移位的 来 自 扩 展段地址 记录 的地址 数 据相加 获 得 数 据 记录 的 绝对 存 储器地址。  
以下的例子演示了这个过 程…  
来自 数 据 记录地址域的地址 2462  
扩展段地址 记录数据域 + 1200  
\---------  
绝对存 储 器地址 00014462

Intel HEX 文件例子:  
下面是一个 完整的Intel HEX 文件的例子:  
:10001300AC12AD13AE10AF1112002F8E0E8F0F2244  
:10000300E50B250DF509E50A350CF5081200132259  
:03000000020023D8  
:0C002300787FE4F6D8FD7581130200031D  
:10002F00EFF88DF0A4FFEDC5F0CEA42EFEEC88F016  
:04003F00A42EFE22CB  
:00000001FF

--------------------

SREC  
SREC全称Motorola S-record，一种文件格式，由摩托罗拉创建的，该文件使用ASCII HEX文件格式表达二进制信息。这种格式也叫做SRECORD, SREC, S19, S28, S37。通常用于微控制器编程，EPROMs和其他可编程的逻辑器件。在通常的应用中，编译器或汇编器将程序的源代码（如C语言或汇编语言）转换成机器代码，并将其输出到一个HEX文件。然后这个HEX文件被程序员烧写到ROM中，或者转移到目标系统用于装载和执行。  
//SREC格式

//第一行数据  
S0 0F 0000 636B3631302D6C2E73686578 0C  
//行数据  
S2 08 010000 FFFFFFFF FA  
S3 15 08640000 6C0264086C0264086C0264086C026408 16  
S5 03 0002 FA  
S7 05 08640214 78

SREC文件一行为单位，分为5个部分。分别是记录类型域、字节数域、地址域、数据域、校验域。

第一部分类型域是SREC文件的起始标志，代表该行的类型，必须已S开始，值可以是从S0到S9；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jhb2JpbmdqaQ_size_16_color_FFFFFF_t_70]  
第二部分字节数域是每行记录的长度，地址域、数据域、校验域三个域的长度，单位为字节数。

第三部分地址域，该域的长度取决于第一部分类型域。

第四部分数据域，该自动长度=字节数域的值-地址域长度-1（校验域长度）

第五部分校验域，该域长度为1byte(16-bit)，校验方法是：除了类型域的值其他十六进制值每两个一组相加结果末两位为0xFF。

--------------------

读取代码：  
QT语言

#include<stdio.h>
    #include<stdlib.h>
    #include<QDebug>
    #include<QString>
    #include<QByteArray>
    #include<QDebug>
    #include<QFile>
    #include<QDataStream>
    
    static char pq=9;  //规范代码
    
    /****16进制的数据类型*****/
    const QString HexTypeTable[6] =
    {
        "00","01","02","03","04","05",
    };
    
    /****配套数据类型使用的枚举变量*****/
    typedef enum __tagHexType
    {
        RECORD_DATA = 0,
        RECORD_END_OF_FILE,
        RECORD_EXTENDED_SEGMENT_ADDRESS,
        RECORD_START_SEGMENT_ADDRESS,
        RECORD_EXTENDED_LINEAR_ADDRESS,
        RECORD_START_LINEAR_ADDRESS,
        RECORD_HEX_MAX,
    }emHexType;
    
    typedef enum Boolsymbol
    {
        DATA_Flase = 0,
        DATA_Ture
    }BoolTureFlase;
    
     //定义字符串的类型格式
    typedef struct StringTypes
    {
        char Firstsymbolis;
        char StringCrcis;
        char StringSizeis;
        char StringResultis;
        char StringType;
        //QString BaseAddress;
    }StringType;
    
    static StringType StringTypeLine={DATA_Ture,DATA_Ture,DATA_Ture,DATA_Ture,RECORD_DATA};   //定义字符串的类型格式
    
    /****函数声明*********/
    QString AnalyseHEX(QByteArray dest);
    int mystrlen(const char *StrDest);
    int HexToDec(char *src);
    QString QStringLeftBit(QString src,int num);
    QString QStringToAdd(QString dest,QString src);
    StringType FormatHexjudge(QByteArray src);
    QString BaseAddjudge(QByteArray src);
    void ReadWrite(QString filenameread,QString filenameWrite);
    
    
    /****计算字符串长度*****/
    int mystrlen(const char *StrDest)
    {
        int i;
        i=0;
        while((*StrDest++)!='\0')
        {
            i++;
        }//这个循环体意思是从字符串第一个字符起计数，只遇到字符串结束标志'\0’才停止计数
        return i;
    }
    
    /****16进制转换10进制*****/
    int HexToDec(char *src)
    {
        //将src中的无符号十六进制字符串转为十进制数
        //如src="001A"，则返回26
        //字符串src需要以'\0'作为结束标志
        int value=0,srclen=mystrlen(src);
        int i;
        for(i=0;i<srclen;i++)
        {
            if(src[i]<='9'&&src[i]>='0')
            {
                value=value*16+(int)(src[i]-'0'); //'0'
            }
            else if(src[i]<='f'&&src[i]>='a')
            {
                value=value*16+(int)(src[i]-'a'+10);
            }
            else
            {
                value=value*16+(int)(src[i]-'A'+10);
            }
        }
        return value;//返回转换后的数值
    }
    
    
    /****字符串效验*返回效验的十进制数用来与字符串后两位做比较****/
    QString AnalyseHEX(QByteArray dest)
    {
       unsigned char i=1;
       int tempsum=0;   //必须初始化，否则乱码
       QString stype;
       QString ZERO="0";
       QString Date0x100="100";
       QString result;
       do
       {
           stype = dest.mid(i,2);    //转换成10进制运算后，再转换成十六进制
    
           printf(" %d",HexToDec(stype.toLatin1().data()));
           tempsum+=HexToDec(stype.toLatin1().data());
           i+=2;
       } while (i<(mystrlen(dest)-2));
    
       /***HEX计算公式(0x100-(16进制数据和后两位))再取后两位=字符串后两位*****/
       result=QString::number((HexToDec(Date0x100.toLatin1().data())-HexToDec
                               (QString::number(tempsum,16).right(2).toLatin1().data())),16);
    
       if(result.size()<2)
       {
          int count=2-result.size();
          //printf("count=2-result.right(2).size()=%d\n",count);
           while(count-->0)
           {
             result.insert(0,ZERO);
           }
       }
       //qDebug()<<"result.right(2).toUpper()"<<result.right(2).toUpper();
       return result.right(2).toUpper();
    
    }
    
    
    /***0613*****字符串左移num位*****************/
     QString QStringLeftBit(QString src,int num)  //
     {
         QString zero="0";
         while(num-->0)
         {
             src.insert(src.size()-2,zero);  //末尾位加零
             src.remove(0,1);    //删除起始位
         }
         return src;
     }
    
    
     /***0613*****字符串以十六进制的形式转换成十进制相加，然后转换成十六进制的字符串形式输出*****/
     QString QStringToAdd(QString dest,QString src)
     {
         QString ResultDate;
         QString ZERO="0";
    
         int num1,num2,ans;
         int count;
         bool ok;
         num1=dest.toInt(&ok,16);  //转换成10进制
         num2=src.toInt(&ok,16);
         ans=num1+num2;
         ResultDate=QString::number(ans,16);
    
         /**判断结果字符串与输入的两个字符串的最大差值，用于给结果字符串补零***/
         (dest.size()-ResultDate.size()>src.size()-ResultDate.size())?
                     count=dest.size()-ResultDate.size():count=src.size()-ResultDate.size();
    
         while(count-->0)
         {
             ResultDate.insert(0,ZERO);
         }
    
        return  ResultDate.toUpper();//十进制转换成Qstring的形式输出  toUpper() //转换成大写字母
     }
    
    
    /****文件格式类型判断,有错误打印，返回值为基地址******/
    StringType FormatHexjudge(QByteArray src) //QString *resultBaseAddres
    {
        QByteArray resultString=":00000001FF";
        static uint32_t count_num=0;
        count_num++;
        /******验证一下传入的数据***********/
    
        char *pcdata = src.data();
    
        //printf("Length of src:%d\n",mystrlen(src));   //打印传入数据大小
        while(*pcdata)
        {
            //printf("%c",*pcdata);  //打印原始数据
            ++pcdata;
        }
        //printf("\n");
    
        if(src.left(1)!=":")
        {//不是以":"开始
                StringTypeLine.Firstsymbolis=DATA_Flase;
                printf("Format FirstSymbol wrong!\n");
                system("Pause");
        }
        else
        {
           StringTypeLine.Firstsymbolis=DATA_Ture;
        }
        if(strlen(src)<11)
        {//字符串长度小于11
                printf("Format length wrong!\n");
                system("Pause");
         }
        else
        {
            StringTypeLine.StringSizeis=DATA_Flase;
        }
        if(strcmp(src,resultString)==0)
        {//结束标志
                StringTypeLine.StringResultis=DATA_Ture;
                printf("End of file\n");
    
        }
        else
        {
            StringTypeLine.StringResultis=DATA_Flase;
        }
    
        if(src.right(2)!= AnalyseHEX(src))    //字符效验
        {
            StringTypeLine.StringCrcis=DATA_Flase;  //字符效验失败
            printf("\nSerialcount  is  wrong in  Address=%d\n",count_num);
            printf("XiaoYan_cc:%c%c\n",*src.right(2).data(),*(src.right(2).data()+1));
    
            printf("\nXiaoYan_calcu_int:%d\n",AnalyseHEX(src).toInt());
            printf("XiaoYan_read_int:%d\n",HexToDec(src.right(2).data()));     //读出来的效验值
    
            system("Pause");  //如果效验值错误，暂停界面
        }
        else
        {
            StringTypeLine.StringCrcis=DATA_Ture;    //字符效验正确
            //printf("\nFormat Effect Vaild!!!!!\n");
            while(mystrlen(src)-2>pq)   //打印完所有的数据
            {
              QString st = src.mid(pq,2);
              pq+=2;
    
              printf("%c%c ",*st.toLatin1().data(),*(st.toLatin1().data()+1));
            }
        }
    
         /****判断数据类型****/
    
        QString stringtype = src.mid(7,2);
        //printf("\nstringtype: %c%c\n",*stringtype.toLatin1().data(),*(stringtype.toLatin1().data()+1));
    
        if(stringtype==HexTypeTable[RECORD_DATA])
        {  //00正常数据类型
    
            StringTypeLine.StringType=RECORD_DATA;
    
            QString styadd = src.mid(3,4);
           /****只是分割字符串****/
           // printf("styadd:%c%c%c%c\n",*styadd.toLatin1().data(),*(styadd.toLatin1().data()+1),*(styadd.toLatin1().data()+2),*(styadd.toLatin1().data()+3));
        }
        else if (stringtype==HexTypeTable[RECORD_END_OF_FILE])
        {  //01 用来标识文件结束
           StringTypeLine.StringType=RECORD_END_OF_FILE;
           printf("RECORD_END_OF_FILE\n ");
    
        }
        else if (stringtype==HexTypeTable[RECORD_EXTENDED_LINEAR_ADDRESS])  //TODO:只需要判断一次
        {  //04 扩展线性地址记录
    
            StringTypeLine.StringType=RECORD_EXTENDED_LINEAR_ADDRESS;
            printf("RECORD_EXTENDED_LINEAR_ADDRESS \n");
            QString styadd = src.mid(3,4);
            QString styaddsub = src.mid(9,4);   //字符串拼接
    
            styadd.insert(0,styaddsub);
            //printf("StyaddSub04:%c%c%c%c%c%c%c%c\n",*styadd.toLatin1().data(),*(styadd.toLatin1().data()+1),
            //        *(styadd.toLatin1().data()+2),*(styadd.toLatin1().data()+3),*(styadd.toLatin1().data()+4),*(styadd.toLatin1().data()+5),*(styadd.toLatin1().data()+6),*(styadd.toLatin1().data()+7));
    
           //system("Pause");
        }
        else if(stringtype==HexTypeTable[RECORD_EXTENDED_SEGMENT_ADDRESS])
        {  //02 扩展段地址记录
            StringTypeLine.StringType=RECORD_EXTENDED_SEGMENT_ADDRESS;
            printf("RECORD_EXTENDED_SEGMENT_ADDRESS\n");
    
        }
        else if(stringtype==HexTypeTable[RECORD_START_LINEAR_ADDRESS])
        {  //05 开始线性地址记录
            StringTypeLine.StringType=RECORD_START_LINEAR_ADDRESS;
            printf("RECORD_START_LINEAR_ADDRESS\n");
    
        }
        else if(stringtype==HexTypeTable[RECORD_START_SEGMENT_ADDRESS])
        {  //03 开始段地址记录
           StringTypeLine.StringType=RECORD_START_SEGMENT_ADDRESS;
           printf("RECORD_START_SEGMENT_ADDRESS\n");
    
           system("Pause");    //如果遇到03则暂停，预留处理03的代码  (0613/还未遇到)
        }
        return StringTypeLine;
    }
    
    
    /******判断基地址**如果数据类型为04调用*******/
    QString BaseAddjudge(QByteArray src)
    {
      QString resultBaseAddres;
      QString stringtype = src.mid(7,2);         /****判断数据类型****/
      if (stringtype==HexTypeTable[RECORD_EXTENDED_LINEAR_ADDRESS])  //TODO:只需要判断一次RECORD_EXTENDED_LINEAR_ADDRESS
      {  //04 扩展线性地址记录
          QString styadd = src.mid(3,4);
          QString styaddsub = src.mid(9,4);   //字符串拼接
    
          styadd.insert(0,styaddsub);
          printf("StyaddSub04:%c%c%c%c%c%c%c%c\n",*styadd.toLatin1().data(),*(styadd.toLatin1().data()+1),
                  *(styadd.toLatin1().data()+2),*(styadd.toLatin1().data()+3),*(styadd.toLatin1().data()+4),*(styadd.toLatin1().data()+5),*(styadd.toLatin1().data()+6),*(styadd.toLatin1().data()+7));
    
          return styadd;
    
      }
    
      if (stringtype==HexTypeTable[RECORD_EXTENDED_SEGMENT_ADDRESS])  //TODO:只需要判断一次RECORD_EXTENDED_LINEAR_ADDRESS
      {  //02 扩展段地址记录
    
          QString Basezer0 = "0000";
          QString styaddsub = src.mid(9,4);   //字符串拼接
    
          Basezer0.insert(4,styaddsub);
          Basezer0=QStringLeftBit(Basezer0,1);
    
          printf("StyaddSub02:%c%c%c%c%c%c%c%c\n",*Basezer0.toLatin1().data(),*(Basezer0.toLatin1().data()+1),
                  *(Basezer0.toLatin1().data()+2),*(Basezer0.toLatin1().data()+3),*(Basezer0.toLatin1().data()+4),*(Basezer0.toLatin1().data()+5),*(Basezer0.toLatin1().data()+6),*(Basezer0.toLatin1().data()+7));
    
          return Basezer0; //在02数据类型的方式下需要左移一位
      }
      return resultBaseAddres;
    }
    
    
    /****新字符串拼接*****/
    QString FormatTranQARRYbyte(QByteArray src)
    {
        char count=9;
        char newcount=10;
        QString ResultDate;
        static QString resultBaseAddress="00000000";             //static 修饰只初始化一次 //0x08000000
        QString space=" ";
    
        StringTypeLine=FormatHexjudge(src);
    
        if(StringTypeLine.StringCrcis==DATA_Ture)   //如果效验码正确
        {
            if(StringTypeLine.StringType==RECORD_EXTENDED_LINEAR_ADDRESS)       //如果是扩展性数据类型 04
            {
                    resultBaseAddress=BaseAddjudge(src);            //接收扩展地址
                    qDebug()<<"resultBaseAddress"<<resultBaseAddress;
            }
    
            if(StringTypeLine.StringType==RECORD_EXTENDED_SEGMENT_ADDRESS)       //如果是段数据类型 02
            {
                    resultBaseAddress=BaseAddjudge(src);
                    qDebug()<<"resultBaseAddress"<<resultBaseAddress;
            }
    
            ResultDate=resultBaseAddress; //第一个是地址
            ResultDate=QStringToAdd(ResultDate,src.mid(3,4));  //基地址和绝对地址相加
    
            if(StringTypeLine.Firstsymbolis==DATA_Ture)   //如果字符串的第一个符号是“:”
            {
             ResultDate.insert(8,src.left(1));    //插入符号
             ResultDate.insert(9,space);
            }
    
            while(mystrlen(src)-2>count)   //打印完所有的数据
            {
              ResultDate.insert(newcount,src.mid(count,2));
              newcount=newcount+3;
    
              ResultDate.insert(newcount,space);
              count=count+2;
            }
    
            if(StringTypeLine.StringType==RECORD_DATA)    //当数据类型为00的时候才打印
            {
             printf("\n");
             qDebug()<<"ResultDate  "<<ResultDate<<endl<<endl<<endl;
            }
        }
      return ResultDate;
    }
    
    
    #if 0
    /***按行读取HEX文件并进行处理*****/
    void read(QString filename)
     {
         QFile file(filename);
         if(!file.open(QFile::ReadOnly | QFile::Text))
         {
             qDebug() << " Could not open the file for reading";
             return;
         }
    
         QTextStream in(&file);
         while(!in.atEnd())
         {
         QString myText = in.readLine();
    
         QString str(myText);
         QByteArray bytes = str.toLatin1();   //Qstring 转 QByteArray
         qDebug() << bytes;
    
         FormatTranQARRYbyte(bytes);
    
         printf("\n\n\n");
         }
    
         file.close();
     }
    
    /***按行读取HEX文件并进行处理*****/
    void Write(QString filename)
    {
        QFile file(filename);
        if(!file.open(QFile::WriteOnly | QFile::Text))
        {
            qDebug() << " Could not open the file for reading";
            return;
        }
        //QTextStream stream(&file);
        //stream.seek(file.size());
        QString resultString=":00000001FF\n";
        QString EnterResul="\n";
        QByteArray AER=":10246200464c5549442050524f46494c4500464c33";
    
        file.write(FormatTranQARRYbyte(AER).toUtf8());
        file.write(EnterResul.toUtf8());
        file.write(resultString.toUtf8());
    
       file.close();
       return;
    }
    #endif
    
    /***按行读取HEX文件并进行处理*****/
    void ReadWrite(QString filenameread,QString filenameWrite)
     {
         QString EnterResul="\n";
         QFile fileread(filenameread);
         if(!fileread.open(QFile::ReadOnly | QFile::Text))
         {
             qDebug() << " Could not open the file for reading";
             return;
         }
    
    
         QFile filewrite(filenameWrite);
         if(!filewrite.open(QFile::WriteOnly | QFile::Text))
         {
             qDebug() << " Could not open the file for reading";
             return;
         }
    
         QTextStream in(&fileread);
         while(!in.atEnd())
         {
             QString myText = in.readLine();
    
             QString str(myText);
             QByteArray bytes = str.toLatin1();   //Qstring 转 QByteArray
             qDebug() << bytes;
    
             QString ResultText;
             ResultText=FormatTranQARRYbyte(bytes);
             if(StringTypeLine.StringType==RECORD_DATA)        //只将数据类型为 00 的字符串写入
             {
                 filewrite.write(ResultText.toUtf8());                 //写入数据
                 filewrite.write(EnterResul.toUtf8());                     //写入回车
             }
             printf("\n");
         }
    
         fileread.close();
         filewrite.close();
     }
    
    
    
    /**0613生成成功**/
    int main()
    {
         QString filename = "C:/Users/Administrator/Desktop/HEX2/VCU_S32K14X.hex";
         //QString filename = "C:/Users/Administrator/Desktop/HEX2/Projec.hex";
         QString filewritename = "C:/Users/Administrator/Desktop/HEX2/Pro1.hex";
    
    
        //QByteArray AER=":020000040800F2";
       // QByteArray AER=":105CC00010831C46234618465DF8044B704708B500";
        //FormatTranQARRYbyte(AER);
    
         ReadWrite(filename,filewritename);
    
    }

--------------------

C\#语言  
头文件

#ifndef CHEX_H
    #define CHEX_H
     
    #include <QFile>
     
    const quint8 MIN_HEX_LINE_COUNT_LENGHT = 12;
     
    typedef enum __tagHexErrorCode
    {
        HEX_NO_ERROR = 0,
        HEX_FORMAT_ERROR,
        HEX_VERIFY_ERROR,
        HEX_LENGHT_ERROR,
        HEX_USERPAPR_EEROR,
    }EHexErrorCode;
     
    typedef enum __tagHexType
    {
        RECORD_DATA = 0,
        RECORD_END_OF_FILE,
        RECORD_EXTENDED_SEGMENT_ADDRESS,
        RECORD_START_SEGMENT_ADDRESS,
        RECORD_EXTENDED_LINEAR_ADDRESS,
        RECORD_START_LINEAR_ADDRESS,
        RECORD_HEX_MAX,
    }emHexType;
     
    typedef struct __tagHexLineData
    {
        emHexType   type;
        quint8      count;
        quint32     address;
        quint8      data[80];
        quint8      checksum;
        quint8      datalen;
    }stHexLineData;
     
    class CHex
    {
    public:
        CHex();
        EHexErrorCode getHexLineData(QByteArray bydata,stHexLineData *p);
    private:
        char ConvertHexChar(char ch);
    };
     
    #endif // CHEX_H

源文件

#include "chex.h"
     
    const QString HexTypeTable[6] =
    {
        "00","01","02","03","04","05",
    };
     
    CHex::CHex()
    {
     
    }
     
    char CHex::ConvertHexChar(char ch)
    {
        if((ch >= '0') && (ch <= '9'))
            return (ch-0x30);
        else if((ch >= 'A') && (ch <= 'F'))
            return ((ch-'A')+10);
        else if((ch >= 'a') && (ch <= 'f'))
            return ((ch-'a')+10);
        else return (-1);
    }
     
    EHexErrorCode CHex::getHexLineData(QByteArray bydata,stHexLineData *p)
    {
        quint8 i = 0;
        quint8 cs_temp = 0;
        QString str(bydata);
        char *pcdata = bydata.data();
        quint32 linelen = str.size();
        if((linelen < MIN_HEX_LINE_COUNT_LENGHT)) {return HEX_LENGHT_ERROR;}
        if(*pcdata != 0x3A) {return HEX_FORMAT_ERROR;}//必须以":"号开始
        //获取Type
        QString stype = str.mid(7,2);
        for(i = 0; i < RECORD_HEX_MAX; i++)
        {
            if(stype == HexTypeTable[i])
            {
                p->type = (emHexType)i;
                break;
            }
        }
        if(i == RECORD_HEX_MAX) {qDebug("HEX_FORMAT_ERROR");return HEX_FORMAT_ERROR;}
        cs_temp += (ConvertHexChar(*(pcdata + 7)) << 4) | ConvertHexChar(*(pcdata + 8));
        //获取count
        p->count = (ConvertHexChar(*(pcdata + 1)) << 4) | ConvertHexChar(*(pcdata + 2));
        cs_temp += p->count;
        if(p->count != (((linelen - 2) / 2) - 5)) {qDebug("HEX_FORMAT_ERROR");return HEX_FORMAT_ERROR;}
        //获取address
        p->address = (ConvertHexChar(*(pcdata + 3)) << 12) | (ConvertHexChar(*(pcdata + 4)) << 8) | (ConvertHexChar(*(pcdata + 5)) << 4) | ConvertHexChar(*(pcdata + 6));
        cs_temp += (p->address >> 8) & 0xFF;
        cs_temp += p->address & 0xFF;
        //获取data
        for(i = 0; i < p->count; i++)
        {
            p->data[i] = (ConvertHexChar(*(pcdata + 2*i + 9)) << 4) | ConvertHexChar(*(pcdata + 2*i + 10));
            cs_temp += p->data[i];
        }
        p->checksum = (ConvertHexChar(*(pcdata + 2*i + 9)) << 4) | ConvertHexChar(*(pcdata + 2*i + 10));
        if(p->checksum != ((0x100 - cs_temp) & 0xFF))
        {
            qDebug("HEX_VERIFY_ERROR");
            return HEX_VERIFY_ERROR;
        }
        p->datalen = p->count;
     
        return HEX_NO_ERROR;
    }

[2019083116155586.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/3c851c3e33d34c71a3e361d8e37cbf57.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jhb2JpbmdqaQ_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/e3d38ff54659443398625ad212d544ef.png