精华内容
下载资源
问答
  • Hex文件

    2019-09-20 21:21:55
    那么什么是Hex文件呢?IntelHex文件是由一行行符合IntelHex文件格式的文本所构成的ASCII文本文件。在IntelHex文件中,每一行包含一个Hex记录。这些记录由对应机器语言码和常量数据的十六进制编码数字组成。IntelHex...

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

    19.3.1 Hex的结构

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

      :llaaaatt[dd...]cc 

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

    1)   “:”: 每个Intel Hex记录都由冒号开头。

    2)   “ll”:数据长度域,它代表记录当中数据字节(dd...)的数量。

    3)   “aaaa ”:地址域,它代表记录当中数据的起始地址。

    4)   “tt” :代表Hex记录类型的域,它可能是以下数据当中的一个:

                    00 – 数据记录 

                    01 – 文件结束记录 

                    02 – 扩展段地址记录 

                    04 – 扩展线性地址记录 

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

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

     

    19.3.2 Hex的数据记录

    Intel Hex文件由任意数量以回车换行符结束的数据记录组成,数据记录(从GPIO实验的GPIO.hex提取出来,可以用NotePad++打开Hex文件)如图19.3-2。

     

     

    图19.3-2 GPIO.hex记录

     

       从图19.3-2可以观察到GPIO.hex第一行数据记录“020000040000FA”,

      其中

      02是这个记录当中数据字节的数量。

      0000 是数据将被下载到存储器当中的地址。

      00 是记录类型(数据记录)。

      00040000是数据。

    FA 是这个记录的校验和。

     

    检验值计算方法如下:

    0x01+~(0x02+0x00+0x00+0x04+0x00+0x00+0x00)=0xFA

     

    更方便的计算方式可以使用“单片机多功能调试助手”进行计算,在【数据校验】中填入“020000040000”,点击计算,在“Intex Hex 校验和”文本框得出计算结果,如图19.3-3。

     

    图19.3-3 快捷计算Intel Hex校验和

     

    ……………………………………………………

     

    书籍下载地址(复制到下载工具进行下载):

     

    http://files.cnblogs.com/wenziqi/ARMCortex-M0原理与应用实践.part1.rar

     

    http://files.cnblogs.com/wenziqi/ARMCortex-M0原理与应用实践.part2.rar

     

    注:书籍内容会不定期进行更新!

    转载于:https://www.cnblogs.com/locean/p/4669406.html

    展开全文
  • HEX文件

    2018-03-19 13:05:01
    (1)什么是Hex文件呢? Intel Hex文件是由一行行符合Intel Hex文件格式的文本所构成的ASCII文本文件。在Intel Hex文件中,每一行包含一个Hex记录。这些记录由对应机器语言码和常量数据的十六进制编码数字组成。...

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

                     

    (2)Hex的结构
        Intel Hex由任意数量的十六进制记录组成。每个记录包含5个域,它们按以下格式排列:
      :llaaaatt[dd...]cc
      每一组字母对应一个不同的域,每一个字母对应一个十六进制编码的数字。每一个域由至少两个十六进制编码数字组成,它们构成一个字节,就像以下描述的那样:
        1) “:”: 每个Intel Hex记录都由冒号开头。
        2) “ll”:数据长度域,它代表记录当中数据字节(dd...)的数量。
        3) “aaaa ”:地址域,它代表记录当中数据的起始地址。
        4) “tt” :代表Hex记录类型的域,它可能是以下数据当中的一个:
                00 – 数据记录
                01 – 文件结束记录
                02 – 扩展段地址记录
                04 – 扩展线性地址记录
        5) “dd” :数据域,它代表一个字节的数据.一个记录可以有许多数据字节。记录当中数据字节的数量必须和数据长度域(ll)中指定的数字相符。
        6) “cc” :校验和域,它表示这个记录的校验和。校验和的计算是通过将记录当中所有十六进制编码数字对的值相加,256为模进行以下补足。

    (3)HEX实例讲解
          hex文件由任意数量以回车换行符结束的数据记录组成,数据记录(从GPIO实验的GPIO.hex提取出来,可以用NotePad++打开Hex文件)如图
                       
        可以观察到GPIO.hex第一行数据记录“020000040000FA”
      其中:
                02是这个记录当中数据字节的数量。
          0000 是数据将被下载到存储器当中的地址。
          00 是记录类型(数据记录)
          00040000是数据。
                FA 是这个记录的校验和。

        检验值计算方法如下:
            0x01+~(0x02+0x00+0x00+0x04+0x00+0x00+0x00)=0xFA
    展开全文
  • HEX 文件

    千次阅读 2012-10-17 22:53:04
    HEX转换bin心得 发表于 2009/6/26 13:01:05 近来写C8051 Boot代码,由于下载数据需要使用bin文件, 但是keil目前只能生成hex... Intel HEX文件是记录文本行的ASCII文本文件,在Intel HEX文件中,每一行是一个HE
    
    
    发表于 2009/6/26 13:01:05

    近来写C8051 Boot代码,由于下载数据需要使用bin文件, 但是keil目前只能生成hex的格式,无奈之下上网找了半天,可没有方便的,无奈之下只能自己写一个了.
     首先需要了解以下HEX的文件信息: 
      Intel HEX文件是记录文本行的ASCII文本文件,在Intel HEX文件中,每一行是一个HEX记录,由十六进制数组成的机器码或者数据常量。Intel HEX文件经常被用

    于将程序或数据传输存储到ROM、EPROM,大多数编程器和模拟器使用Intel HEX文件。 
      HEX格式文件以行为单位,每行由":"(0x3A)开始,以回车键结束(0x0D,0x0A)。行内的数据都是由两个字符表示一个16进制字节,比如"01"就表示数0x01;"0A"就

    表示0x0A。对于16位的地址, 则高位在前低位在后, 比如地址0x010A,在HEX格式文件中就表示为字符串"010a". 下面为HEX文件中的一行: 
     :10000000FF0462FF051EFF0A93FF0572FF0A93FFBC 
     : 号表示一行的开始 
     : 后的第1, 2个字符表示本行包含的数据的长度,这里就是0x10即16个. 
     : 后的第3, 4, 5, 6个字符表示数据存储的起始地址,这里表示从0x0000地址开始存储16个数据,其中高位地址在前,低位地址在后。 
     : 后的第7, 8个字符表示数据的类型
      00 ----数据记录        
      01 ----文件结束记录 
      02 ----扩展段地址记录 
      04 ----扩展线性地址记录

     这里就是0x00即为普通数据记录。 
     自后的32个字符就是本行包含的数据,每两个字符表示一个字节数据,总共有16个字节数据跟行首的记录的长度相一致。 
     最后两个字符表示校验码。 
     
     每个HEX格式的最后一行都是固定为:
     :00000001FF

     以上的信息其实就足够进行HEX转BIN格式的程序的编写。
     我只处理数据类型为0x00及0x01的情况。0x02, 0x04表示对应的存储地址超过了64K,我没有用到.




    这是生成的HEX文件 
    注意: 倒数第2行的 
    :031000001020308D 
     03                3个数据 
       1000            地址0x1000 
           00          数据记录  
             10        数据0x10 
               20      数据0x20 
                 30    数据0x30 
                   8D  校验和 



    :1000000012C02BC02AC029C028C027C026C025C0C6 
    :1000100037C023C022C021C020C01FC01EC01DC0C9 
    :100020001CC01BC01AC011241FBECFE5D4E0DEBF28 
    :10003000CDBF10E0A0E6B0E0E4E4F1E002C005903E 
    :100040000D92AE37B107D9F710E0AEE7B0E001C0CE 
    :100050001D92A038B107E1F762C0D2CF019782307C 
    :100060009105E4F70895CF93DF93EC01892B29F0F4 
    :1000700088EE93E0F3DF2197D9F7DF91CF910895D0 
    :100080001F920F920FB60F9211248F939F9380911E 
    :100090007E0090917F009DBD8CBD85B391E0892746 
    :1000A00085BB9F918F910F900FBE0F901F90189559 
    :1000B000CF93DF931FBC82E08EBD80E090E03AD00A 
    :1000C000282F882331F1C0E0D0E0E22FEF7089F0D3 
    :1000D00089B7846089BFE150FF27EE0FFF1FE05A08 
    :1000E000FF4F8081918190937F0080937E009DBD22 
    :1000F0008CBD22952F708AE8289FC0011124B3DFA0 
    :1001000089B78B7F89BF2196CE0114D0282F8823F1 
    :10011000E1F688EE93E0A7DFDF91CF910895CFE578 
    :10012000D4E0DEBFCDBF81E084BB8FEF85BB789488 
    :10013000BFDFFECFE199FECF9FBB8EBBE09A992730 
    :040140008DB30895DE 
    :1001440044FCACFC09FD34FD82FDC8FD06FE22FE24 
    :0E01540056FE85FE9AFEC1FEE4FE03FF11FF7B 
    :031000001020308D 
    :00000001FF 

    展开全文
  • 内含两个工具: 1.hex文件转化为bin文件,方便单片机IAP下载。 2.单片机flash程序空间校验码计算,提供下位机计算工具,可用于单片机程序版本比对
  • HEX文件编辑器

    2018-09-19 15:27:57
    HEX 文件编辑器,用于修改HEX文件 ,用于HEX文件的合并
  • hex文件转bin文件工具

    2017-12-19 17:00:15
    hex文件转bin文件,包含源代码,将.hex文件拖到hex2bin.exe上即可生成bin文件
  • 这几天在写STM32的ISP烧录工具,因此有涉及到输入hex文件或bin文件进行烧录的问题,所以对hex文件和bin文件进行了些总结。 1 hex介绍Hex 全称 (Intel HEX)文件是由一行行符合Intel HEX文件格式的文本所构成的ASCII...

    这几天在写STM32的ISP烧录工具,因此有涉及到输入hex文件或bin文件进行烧录的问题,所以对hex文件和bin文件进行了些总结。

    1 hex介绍

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

    2 hex与bin的区别

    1     HEX文件是包括地址信息的,而BIN文件格式只包括了数据本身,在烧写或下载HEX文件的时候,一般都不需要用户指定地址,因为HEX文件内部的信息已经包括了地址。而烧写BIN文件的时候,用户是一定需要指定地址信息的。

    2   BIN文件格式,对二进制文件而言,其实没有”格式”。文件只是包括了纯粹的二进制数据。

    3  HEX文件格式

    HEX文件都是由记录(RECORD)组成的。在HEX文件里面,每一行代表一个记录。记录的基本格式为:

     +—————————————————————+
             |  RECORD  | RECLEN |  LOAD  |RECTYPE | INFO or DATA | CHKSUM |
             |  MARK ‘:’|        | OFFSET |        |             |       |
            +—————————————————————+
             |  1-byte  | 1-byte | 2-byte | 1-byte  |   n-byte    | 1-byte |
            +—————————————————————+
     

    记录类型包括:
             ‘00’ DataRrecord:用来记录数据,HEX文件的大部分记录都是数据记录
             ‘01’ End of File Record:用来标识文件结束,放在文件的最后,标识HEX文件的结尾
             ‘02’ Extended SegmentAddress Record: 用来标识扩展段地址的记录

             ‘03’ Start Segment Address Record

              ‘04’ Extended Linear AddressRecord: 用来标识扩展线性地址的记录

              ‘05’ Start Linear Address Record
             
            在上面的后2种记录,都是用来提供地址信息的。每次碰到这2个记录的时候,都可以根据记录计算出一个“基”地址。
            对于后面的数据记录,计算地址的时候,都是以这些“基”地址为基础的。
             
             数据记录的具体格式:
            +—————————————————————+
             |  RECORD  | RECLEN |  LOAD  |RECTYPE | INFO or DATA | CHKSUM |
             |  MARK ‘:’|        | OFFSET|  ‘00’   |             |       |
            +—————————————————————+
             |  1-byte  | 1-byte | 2-byte | 1-byte  |   n-byte    | 1-byte |
            +—————————————————————+        
             
             看个例子:
            :020000040000FA
           :10000400FF00A0E314209FE5001092E5011092E5A3
            :00000001FF        
          
            对上面的HEX文件进行分析:
            第1条记录的长度为02,LOADOFFSET为0000,RECTYPE为04,说明该记录为扩展段地址记录。数据为0000,校验和为
           FA。从这个记录的长度和数据,我们可以计算出一个基地址,这个地址为0X0000。后面的数据记录都以这个地址为基
            地址。
            第2条记录的长度为10(16),LOADOFFSET为0004,RECTYPE为00,说明该记录为数据记录。
           数据为FF00A0E314209FE5001092E5011092E5,共16个BYTE。这个记录的校验和为A3。此时的基地址为0X0000,加上OFFSET,
            这个记录里的16BYTE的数据的起始地址就是0x0000+ 0x0004 = 0x0004.
            第3条记录的长度为00,LOADOFFSET为0000,TYPE = 01,校验和为FF。说明这个是一个END OF FILE RECORD,标识
            文件的结尾。
          
           在上面这个例子里,实际的数据只有16个BYTE:FF00A0E314209FE5001092E5011092E5,其起始地址为0x4

    4   HEX文件和BIN文件大小有区别

         HEX文件是用ASCII来表示二进制的数值。例如一般8-BIT的二进制数值0x3F,用ASCII来表示就需要分别表示字符’3’
         和字符’F’,每个字符需要一个BYTE,所以HEX文件需要 > 2倍的空间。
        对一个BIN文件而言,你查看文件的大小就可以知道文件包括的数据的实际大小。而对HEX文件而言,你看到的文件
        大小并不是实际的数据的大小。一是因为HEX文件是用ASCII来表示数据,二是因为HEX文件本身还包括别的附加信息。


    要想详细了解HEX文件格式, 请参见INTEL HEX PDF文档

    3 hex文件流转bin文件流

    hex.h:

    1. #ifndef __HEX_H_  
    2. #define __HEX_H_  
    3.   
    4. typedef struct{  
    5.     int len; //bin文件大小  
    6.     UINT startAddress; //刷写的起始地址  
    7.     BYTE *pContent;     //转化后的内容  
    8. }HexToBinData;  
    9.   
    10. typedef struct{  
    11.     BYTE data[16];//数据  
    12.     BYTE len;   //数据长度  
    13.     UINT pos;   //偏移地址  
    14.     BYTE type;  //类型  
    15. }HexLinData;  
    16.   
    17. int ConvertHexToBin(const char *str,HexToBinData *pData);  
    18. #endif  
    #ifndef __HEX_H_
    
    
    
    
    

    define _HEX_H

    typedef struct{
    int len; //bin文件大小
    UINT startAddress; //刷写的起始地址
    BYTE *pContent; //转化后的内容
    }HexToBinData;

    typedef struct{
    BYTE data[16];//数据
    BYTE len; //数据长度
    UINT pos; //偏移地址
    BYTE type; //类型
    }HexLinData;

    int ConvertHexToBin(const char *str,HexToBinData *pData);

    endif

    hex.cpp:

    1. //#include “StdAfx.h”  
    2. #include “hex.h”  
    3.   
    4. static BYTE HexCharToByte(char c)  
    5. {  
    6.     if(c>=‘0’ && c<=‘9’)  
    7.         return c -‘0’;  
    8.     else if(c>=‘a’ && c<=‘f’)  
    9.         return c-‘a’+0x0a;  
    10.     else if(c>=‘A’ && c <=‘F’)  
    11.         return c-‘A’+0x0a;  
    12.       
    13.     return -1;  
    14. }  
    15. static BYTE GetFirstByte(const char str)  
    16. {  
    17.     ASSERT(str !=NULL);  
    18.   
    19.     BYTE tmp =0;  
    20.     tmp =HexCharToByte(str[0]);  
    21.     tmp <<=4;  
    22.     tmp +=HexCharToByte(str[1]);  
    23.   
    24.     return tmp;  
    25. }  
    26. //从字符串中获取一行  
    27. static int GetLine(const char *str,char *pBuf)  
    28. {  
    29.     ASSERT(str !=NULL);  
    30.     ASSERT(pBuf !=NULL);  
    31.   
    32.     char *start =strchr((char )str,‘:’);  
    33.     if(NULL ==start){  
    34.         return -1;  
    35.     }  
    36.   
    37.     char end =strstr(start,“\r\n”);  
    38.     char *p =start;  
    39.     char *p2 =pBuf;  
    40.     int len=0;  
    41.     for (;p<end+2;p++,p2++)  
    42.     {  
    43.         if(*p ==‘\0’)  
    44.             break;  
    45.         *p2 =*p;  
    46.         len ++;  
    47.     }  
    48.     *p2 =’\0’;  
    49.   
    50.     return len;  
    51. }  
    52.   
    53. //获取一行的数据  
    54. static int GetHexLineData(const char *line,HexLinData *pData)  
    55. {  
    56.     ASSERT(line !=NULL);  
    57.     ASSERT(pData !=NULL);  
    58.   
    59.     if(line[0] !=‘:’)  
    60.         return -1;  
    61.     int i=1;  
    62.     pData->len =GetFirstByte(&line[i]);  
    63.     i +=2;  
    64.     pData->pos =GetFirstByte(&line[i]);  
    65.     i +=2;  
    66.     pData->pos <<=8;  
    67.     pData->pos +=GetFirstByte(&line[i]);  
    68.     i +=2;  
    69.     pData->type =GetFirstByte(&line[i]);  
    70.     i +=2;  
    71.     for(int j=0;j<pData->len;i+=2,j++){  
    72.         pData->data[j] =GetFirstByte(&line[i]);  
    73.     }  
    74.     return 0;  
    75. }  
    76. //获取第一行指定类型的数据  
    77. static int GetFirstDataLine(const char *str,BYTE type,HexLinData *pData)  
    78. {  
    79.   
    80.     ASSERT(str !=NULL);  
    81.     ASSERT(pData !=NULL);  
    82.   
    83.     char *p =(char )str;  
    84.     char line[128];  
    85.     HexLinData data ={0};  
    86.     int len =strlen(str);  
    87.     int dataLen =0;  
    88.   
    89.     for(;p<str+len;p+=dataLen){  
    90.         memset(line,0,128);  
    91.         dataLen =GetLine(p,line);  
    92.         if(dataLen <0)  
    93.             return -1;  
    94.         memset(&data,0x00,sizeof(HexLinData));  
    95.         if(0 !=GetHexLineData(line,&data))  
    96.             return -1;  
    97.   
    98.         if(data.type ==type){  
    99.             memcpy(pData,&data,sizeof(HexLinData));  
    100.             return 0;  
    101.         }  
    102.     }  
    103.     return -1;  
    104. }  
    105.   
    106. static int GetStartAddress(const char str,UINT *pStartAddress)  
    107. {  
    108.     HexLinData data ={0};  
    109.     UINT basePos=0;  
    110.     UINT pos;  
    111.   
    112.     if(0 !=GetFirstDataLine(str,4,&data))  
    113.         return -1;  
    114.     for(int i=0;i<data.len;i++){  
    115.         basePos <<=8;  
    116.         basePos +=data.data[i];  
    117.     }  
    118.   
    119.     memset(&data,0x00,sizeof(HexLinData));  
    120.     if(0 !=GetFirstDataLine(str,0,&data))  
    121.         return -1;  
    122.     pos =data.pos;  
    123.   
    124.     *pStartAddress =(basePos<<16) +pos;  
    125.     return 0;  
    126. }  
    127.   
    128. int ConvertHexToBin(const char *str,HexToBinData *pData)  
    129. {  
    130.     ASSERT(str !=NULL);  
    131.     ASSERT(pData !=NULL);  
    132.   
    133.   
    134.     UINT startAddress =0;  
    135.     char line[128] ={0};  
    136.     HexLinData data={0};  
    137.     if(0 !=GetStartAddress(str,&startAddress))  
    138.         return -1;  
    139.   
    140.     pData->startAddress =startAddress;  
    141.   
    142.     char *p =(char )str;  
    143.     int binLen =0;  
    144.     int len =0;  
    145.     int size =strlen(str);  
    146.   
    147.     /FILE *file =fopen(“test.hex”,”wb+”); 
    148.     fseek(file,0,SEEK_SET); 
    149.     FILE *file1 =fopen(“test.bin”,”wb+”); 
    150.     fseek(file1,0,SEEK_SET);/  
    151.     for(binLen=0;p<str+size;p +=len){  
    152.         memset(line,0,128);  
    153.         len =GetLine(p,line);  
    154.         if(len <0)  
    155.             break;  
    156.         /fwrite(line,1,len,file);/  
    157.         memset(&data,0x00,sizeof(HexLinData));  
    158.         if(0 !=GetHexLineData(line,&data))  
    159.             return -1;  
    160.         if(data.type ==0){  
    161.             binLen +=data.len;  
    162.             /fwrite(data.data,1,data.len,file1);/  
    163.         }  
    164.     }  
    165.     /fclose(file); 
    166.     fclose(file1);/  
    167.     pData->len =binLen;  
    168.     pData->pContent =(BYTE )malloc(pData->len+1);  
    169.     if(pData->pContent ==NULL)  
    170.         return -1;  
    171.   
    172.     p =(char )str;  
    173.     binLen =0;  
    174.     len =0;  
    175.     for(binLen=0;p<str+size;p +=len){  
    176.         memset(line,0,128);  
    177.         len =GetLine(p,line);  
    178.         if(len <0)  
    179.             break;  
    180.         memset(&data,0x00,sizeof(HexLinData));  
    181.         if(0 !=GetHexLineData(line,&data))  
    182.             return -1;  
    183.         if(data.type ==0){  
    184.             memcpy(pData->pContent+binLen,data.data,data.len);  
    185.             binLen +=data.len;  
    186.         }  
    187.     }  
    188.   
    189.     return 0;  
    190. }  
    //#include "StdAfx.h"

    include "hex.h"

    static BYTE HexCharToByte(char c)
    {
    if(c>='0' && c<='9')
    return c -'0';
    else if(c>='a' && c<='f')
    return c-'a'+0x0a;
    else if(c>='A' && c <='F')
    return c-'A'+0x0a;

    return -1;
    
    } static BYTE GetFirstByte(const char *str) { ASSERT(str !=NULL);
    BYTE tmp =0;
    tmp =HexCharToByte(str[0]);
    tmp &lt;&lt;=4;
    tmp +=HexCharToByte(str[1]);
    
    return tmp;
    
    } //从字符串中获取一行 static int GetLine(const char *str,char *pBuf) { ASSERT(str !=NULL); ASSERT(pBuf !=NULL);
    char *start =strchr((char *)str,':');
    if(NULL ==start){
        return -1;
    }
    
    char *end =strstr(start,"\r\n");
    char *p =start;
    char *p2 =pBuf;
    int len=0;
    for (;p&lt;end+2;p++,p2++)
    {
        if(*p =='\0')
            break;
        *p2 =*p;
        len ++;
    }
    *p2 ='\0';
    
    return len;
    
    } //获取一行的数据 static int GetHexLineData(const char *line,HexLinData *pData) { ASSERT(line !=NULL); ASSERT(pData !=NULL);
    if(line[0] !=':')
        return -1;
    int i=1;
    pData-&gt;len =GetFirstByte(&amp;line[i]);
    i +=2;
    pData-&gt;pos =GetFirstByte(&amp;line[i]);
    i +=2;
    pData-&gt;pos &lt;&lt;=8;
    pData-&gt;pos +=GetFirstByte(&amp;line[i]);
    i +=2;
    pData-&gt;type =GetFirstByte(&amp;line[i]);
    i +=2;
    for(int j=0;j&lt;pData-&gt;len;i+=2,j++){
        pData-&gt;data[j] =GetFirstByte(&amp;line[i]);
    }
    return 0;
    
    } //获取第一行指定类型的数据 static int GetFirstDataLine(const char *str,BYTE type,HexLinData *pData) {
    ASSERT(str !=NULL);
    ASSERT(pData !=NULL);
    
    char *p =(char *)str;
    char line[128];
    HexLinData data ={0};
    int len =strlen(str);
    int dataLen =0;
    
    for(;p&lt;str+len;p+=dataLen){
        memset(line,0,128);
        dataLen =GetLine(p,line);
        if(dataLen &lt;0)
            return -1;
        memset(&amp;data,0x00,sizeof(HexLinData));
        if(0 !=GetHexLineData(line,&amp;data))
            return -1;
    
        if(data.type ==type){
            memcpy(pData,&amp;data,sizeof(HexLinData));
            return 0;
        }
    }
    return -1;
    
    } static int GetStartAddress(const char *str,UINT *pStartAddress) { HexLinData data ={0}; UINT basePos=0; UINT pos;
    if(0 !=GetFirstDataLine(str,4,&amp;data))
        return -1;
    for(int i=0;i&lt;data.len;i++){
        basePos &lt;&lt;=8;
        basePos +=data.data[i];
    }
    
    memset(&amp;data,0x00,sizeof(HexLinData));
    if(0 !=GetFirstDataLine(str,0,&amp;data))
        return -1;
    pos =data.pos;
    
    *pStartAddress =(basePos&lt;&lt;16) +pos;
    return 0;
    
    } int ConvertHexToBin(const char *str,HexToBinData *pData) { ASSERT(str !=NULL); ASSERT(pData !=NULL);
    UINT startAddress =0;
    char line[128] ={0};
    HexLinData data={0};
    if(0 !=GetStartAddress(str,&amp;startAddress))
        return -1;
    
    pData-&gt;startAddress =startAddress;
    
    char *p =(char *)str;
    int binLen =0;
    int len =0;
    int size =strlen(str);
    
    /*FILE *file =fopen("test.hex","wb+");
    fseek(file,0,SEEK_SET);
    FILE *file1 =fopen("test.bin","wb+");
    fseek(file1,0,SEEK_SET);*/
    for(binLen=0;p&lt;str+size;p +=len){
        memset(line,0,128);
        len =GetLine(p,line);
        if(len &lt;0)
            break;
        /*fwrite(line,1,len,file);*/
        memset(&amp;data,0x00,sizeof(HexLinData));
        if(0 !=GetHexLineData(line,&amp;data))
            return -1;
        if(data.type ==0){
            binLen +=data.len;
            /*fwrite(data.data,1,data.len,file1);*/
        }
    }
    /*fclose(file);
    fclose(file1);*/
    pData-&gt;len =binLen;
    pData-&gt;pContent =(BYTE *)malloc(pData-&gt;len+1);
    if(pData-&gt;pContent ==NULL)
        return -1;
    
    p =(char *)str;
    binLen =0;
    len =0;
    for(binLen=0;p&lt;str+size;p +=len){
        memset(line,0,128);
        len =GetLine(p,line);
        if(len &lt;0)
            break;
        memset(&amp;data,0x00,sizeof(HexLinData));
        if(0 !=GetHexLineData(line,&amp;data))
            return -1;
        if(data.type ==0){
            memcpy(pData-&gt;pContent+binLen,data.data,data.len);
            binLen +=data.len;
        }
    }
    
    return 0;
    
    }

    只有一个接口函数:

    1. int ConvertHexToBin(const char *str,HexToBinData *pData);  
    int ConvertHexToBin(const char *str,HexToBinData *pData);

    它的作用是将hex文件流str直接转化为bin文件流,并存储到HexToBinData结构体中,若成功则返回0,失败则返回非0.
    展开全文
  • 将elf文件转换为hex文件的小程序,使用前安装arm-none-eabi编译工具链,复制到elf文件所在目录双击执行,若当前文件没有.elf文件,则会提示 No such file,若转换成功则会在目录内生成HexFile.hex文件
  • Hex文件格式

    2016-03-26 15:00:44
    Hex文件格式的说明
  • HEX文件格式文档(用于解析HEX文件)
  • QT实现HEX文件操作

    2019-12-04 18:14:44
    资源中包括《HEX文件格式解析.pdf》文章,使用QT实现HEX文件生成、HEX文件解析、文件读写及文件拼接功能的工程源码,因项目开发写的工程,可以直接使用,也可作为HEX文件操作参考。
  • 00 关于HexHex文件格式(本文讲的是Intel Hex)是好多好多年以前定义的格式,解析这文件的工具网上...话说回来,常用的解析Hex文件的工具有:IntelHex(Python),bincopy(Python)以及SRecordizer(C++),当然还有其他的...
  • HEX文件的格式简介

    2020-07-18 02:00:23
    HEX文件是包括地址信息的,在烧写或下载HEX文件的时候,一般都不需要用户指定地址,因为HEX文件内部的信息已经包括了地址。
  • out文件转hex文件方法

    2018-03-16 16:09:02
    .OUT文件转换为.HEX文件方法 1. 工具 TI公司提供的hex2000软件 2. 步骤 举例说明将 Powervotex305KTL_MasterV1.0.2.out 转换成Powervortex305KTL_Master_ V1.0.2.hex文件 2.1复制出hex2000,并与xxx.out文件放到同一...
  • Hex文件合并

    2020-11-04 17:38:38
    Hex文件合并 一、合并方法 用文本编辑器打开第一个Hex文件,将文件最后一行用下一个Hex文件替换掉即可,多个文件一次类推
  • hex文件烧录器

    2018-04-17 17:18:51
    支持所有.hex文件烧录,操作简单。支持所有.hex文件烧录,操作简单。
  • 采用C#语言编写,VS2010工具编译,可以将.hex文件转换成.txt文件,将.hex文件中的数据提取到.txt文件中,每行显示一个数据,可选择1byte/2byte/4byte转换方式。
  • 把BootLoader hex文件和app hex文件合并为一个hex文件,烧录到嵌入式系统里面,亲自测试好用
  • 易语言读HEX文件源码

    2020-07-23 12:55:18
    易语言读HEX文件源码,读HEX文件,二转十,十六转二,十六转十
  • hex文件转换成bin文件

    2018-03-26 12:26:40
    支持hex文件转换成bin文件,自己已经进行测试过,真是有效
  • hex文件说明

    万次阅读 2018-11-18 13:25:01
    在项目学习的时候,烧录生成的工程文件.hex给stm32单片机,需要分析hex文件的内容,并对其中某些数据进行修改。通过学习,了解了hex的格式内容。并记录之 在工程项目中是把程序下载到flash 的0x0800 0000开头的位置...
  • 首先这多个HEX文件自己已经偏移好了,hex文件已经记录了偏移的地址信息。 用记事本打开第一个hex文件:test1.hex :020000040000FA文件头记录 :1000000018F09FE518F09FE518F09FE518F09FE5C0程序区开始 …… ...
  • hex文件转bin

    2017-05-03 09:05:47
    hex文件转bin
  • hex文件格式

    2019-09-26 23:58:13
    hex文件格式是可以烧写到单片机中,被单片机执行的一种文件格式,生成Hex文件的方式有很多种,可以通过不同的编译器将C程序或者汇编程序编译生成hex。 Hex文件格式解析 Hex文件如果用特殊的程序来查看(一般...
  • hex文件解析

    2020-03-28 16:38:10
    hex(hexadecimal),十六进制的英文缩写,*.hex为后缀的文件为称之为hex文件,主要用于保 存单片机固件,可直接下载到单片机中,故又称为可执行文件 1、 hex文件内容 打开任意一个hex文件,内容如下(为了内容展示...
  • 用VS2015编写,可以将HEX文件转成BIN文件,并对地址空缺部分用0xff补齐。
  • IntelHEX文件是记录文本行的ASCII文本文件,下面是IntelHEX文件格式,在IntelHEX文件中,每一行是一个HEX记录由十六进制数组成的机器码或者静态数据,IntelHEX文件经常被用于将程序或数据传输存储到ROM.EPROM,大多数编程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,104
精华内容 2,441
关键字:

hex文件