（转）keil生成的Hex和Bin的区别及hex转bin的源码

前面我们烧写无论是DFU还是usb直接读bin烧到flash，
这里都需要将keil生产的hex文件转换到bin
那么我们可以根据hex和bin的不同，直接烧写hex吗？
答案是肯定的，下面转载他们的区别，然后我们可以载前面利用u盘复制bin来烧flash改造为直接通过复制hex来烧flash。
当然这是我们下一步要做的。
1 － HEX文件是包括地址信息的，而BIN文件格式只包括了数据本身在烧写或下载HEX文件的时候，一般都不需要用户指定地址，因为HEX文件内部的信息已经包括了地址。而烧写BIN文件的时候，用户是一定需要指定地址信息的。
HEX格式文件以行为单位，每行由“：”（0x3a）开始，以回车键结束(0x0d,0x0a)。

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

4 － 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' Data Rrecord：用来记录数据，HEX文件的大部分记录都是数据记录
'01' End of File Record: 用来标识文件结束，放在文件的最后，标识HEX文件的结尾
'04' Extended Linear Address Record: 用来标识扩展线性地址的记录
'02' Extended Segment 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，LOAD OFFSET为0000，RECTYPE为04，说明该记录为扩展段地址记录。数据为0000，校验和为FA。从这个记录的长度和数据，我们可以计算出一个基地址，这个地址为0X0000。后面的数据记录都以这个地址为基地址。
第2条记录的长度为10（16），LOAD OFFSET为0004，RECTYPE为00，说明该记录为数据记录。
数据为FF00A0E314209FE5001092E5011092E5，共16个BYTE。这个记录的校验和为A3。此时的基地址为0X0000，加上OFFSET，这个记录里的16BYTE的数据的起始地址就是0x0000 + 0x0004 = 0x0004.
第3条记录的长度为00，LOAD OFFSET为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文件本身还包括别的附加信息。

2 个回复

admin

网上找的一个hex转bin程序：

这个烂编辑器，把代码的部分给隐藏了，我正在找这个编辑器的问题，先上图片吧

>>引用自：http://www.cnblogs.com/sky1991 ... .html

admin

赞同来自: 一粒尘a_a

都还没验证，下面是另外一种方式

#include <stdio.h>

#include <stdlib.h>

#include <string.h>



typedef signed char int8_t;

typedef unsigned char uint8_t;

typedef signed short int16_t;

typedef unsigned short uint16_t;

typedef signed int int32_t;

typedef unsigned int uint32_t;

typedef float flt_t;

typedef double lflt_t;



#define _not_hex_(src) ((('0' > src) || ('9' < src)) && (('a' > src) || ('f' < src)) && (('A' > src) || ('F' < src)))



#define _hex_trans_eq_(src,dst) \

{ \

        if (_not_hex_(src)) \

        { \

                return HEX_ERR; \

        } \

        if (('0' <= (src)) && ('9' >= (src))) \

        { \

                dst = (src) - '0'; \

        } \

        else if (('a' <= (src)) && ('f' >= (src))) \

        { \

                dst = (src) - 'a' + 10; \

        } \

        else if (('A' <= (src)) && ('F' >= (src))) \

        { \

                dst = (src) - 'A' + 10; \

        } \

}



#define _hex_trans_or_(src,dst) \

{ \

        if (_not_hex_(src)) \

        { \

                return HEX_ERR; \

        } \

        if (('0' <= (src)) && ('9' >= (src))) \

        { \

                dst |= (src) - '0'; \

        } \

        else if (('a' <= (src)) && ('f' >= (src))) \

        { \

                dst |= (src) - 'a' + 10; \

        } \

        else if (('A' <= (src)) && ('F' >= (src))) \

        { \

                dst |= (src) - 'A' + 10; \

        } \

}



#define _hex_trans_or_shift_(src,dst) \

{ \

        dst <<= 4; \

        _hex_trans_or_(src,dst); \

}



enum RESULT{HEX_ERR = -1, HEX_DATA_OK = 0, HEX_END_OK = 1, HEX_LBA_OK = 2, HEX_SEG_OK = 3};



int8_t _hex2bin_(const uint8_t* src, uint8_t* dst, uint8_t* data_type, uint8_t* data_len, uint16_t* data_addr)

{

        uint8_t check_sum, i;

        // 如果源code长度小于11，表明源code有误！

        if (11 > strlen((const char*)src))

        {

                return HEX_ERR;

        }



        // 校验起始字节是否为':'，如果不为':'，表明源code有误！

        if (':' != *src++)

        {

                return HEX_ERR;

        }



        // 得到数据长度的高4位

        _hex_trans_eq_(*src, *data_len);

        src++;

        // 得到数据长度的低4位

        _hex_trans_or_shift_(*src, *data_len);

        src++;

        // 校验和

        check_sum = *data_len;



        // 得到数据地址

        _hex_trans_eq_(*src, *data_addr);

        src++;

        _hex_trans_or_shift_(*src, *data_addr);

        src++;

        // 校验和

        check_sum += *data_addr;

        _hex_trans_or_shift_(*src, *data_addr);

        src++;

        _hex_trans_or_shift_(*src, *data_addr);

        src++;

        // 校验和

        check_sum += *data_addr;



        // 得到数据类型

        _hex_trans_eq_(*src, *data_type);

        src++;

        _hex_trans_or_shift_(*src, *data_type);

        src++;

        // 校验和

        check_sum += *data_type;



        switch (*data_type)

        {

        case 0: // 数据记录

                for (i = *data_len; i; i--, dst++)

                {

                        _hex_trans_eq_(*src, *dst);

                        src++;

                        _hex_trans_or_shift_(*src, *dst);

                        src++;

                        // 校验和

                        check_sum += *dst;

                }

                // 校验

                _hex_trans_eq_(*src, i);

                src++;

                _hex_trans_or_shift_(*src, i);

                check_sum += i;

                return check_sum? HEX_ERR : HEX_DATA_OK;

        case 1: // 文件结束记录

                if (*data_addr)

                {

                        return HEX_ERR;

                }

                // 校验

                _hex_trans_eq_(*src, i);

                src++;

                _hex_trans_or_shift_(*src, i);

                check_sum += i;

                return check_sum? HEX_ERR : HEX_END_OK;

        case 2: // 扩展段地址记录

                if (*data_addr)

                {

                        return HEX_ERR;

                }

                // 得到扩展段地址

                _hex_trans_eq_(*src, *data_addr);

                src++;

                _hex_trans_or_shift_(*src, *data_addr);

                src++;

                // 校验和

                check_sum += *data_addr;

                _hex_trans_or_shift_(*src, *data_addr);

                src++;

                _hex_trans_or_shift_(*src, *data_addr);

                src++;

                // 校验和

                check_sum += *data_addr;

                return check_sum? HEX_ERR : HEX_SEG_OK;

        case 4: // 扩展线性地址记录

                if (*data_addr)

                {

                        return HEX_ERR;

                }

                // 得到扩展段地址

                // 得到数据地址

                _hex_trans_eq_(*src, *data_addr);

                src++;

                _hex_trans_or_shift_(*src, *data_addr);

                src++;

                // 校验和

                check_sum += *data_addr;

                _hex_trans_or_shift_(*src, *data_addr);

                src++;

                _hex_trans_or_shift_(*src, *data_addr);

                src++;

                // 校验和

                check_sum += *data_addr;

                return check_sum? HEX_ERR : HEX_LBA_OK;

        default:

                return HEX_ERR;

        }

        return HEX_ERR;

}



int8_t hex2bin(const int8_t* src_file_path, const int8_t* dst_file_path)

{

        uint8_t buffer_hex[1024], buffer_bin[256];

        uint8_t data_type, len_bin;

        uint16_t addr_low;

        uint32_t addr_high = 0;

        FILE* src_file;

        FILE* dst_file;

        src_file = fopen((const char*)src_file_path, "r");

        if (!src_file)

        {

                return -1;

        }

        dst_file = fopen((const char*)dst_file_path, "wb");

        if (!dst_file)

        {

                fclose(src_file);

                return -1;

        }

        for ( ; !feof(src_file); )

        {

                if (NULL == fgets((char*)buffer_hex, 1024, src_file))

                {

                        break;

                }

                if (HEX_ERR == _hex2bin_((const uint8_t*)buffer_hex, (uint8_t*)buffer_bin, &data_type, &len_bin, &addr_low))

                {

                        break;

                }

                switch (data_type)

                {

                case 0: // 数据记录

                        if (ftell(dst_file) != addr_low + addr_high)

                        {

                                fseek(dst_file, addr_low + addr_high, SEEK_SET);

                        }

                        if (1 != fwrite((const uint8_t*)buffer_bin, len_bin, 1, dst_file))

                        {

                                fclose(src_file);

                                fclose(dst_file);

                                return -1;

                        }

                        break;

                case 1: // 文件结束记录

                        fclose(src_file);

                        fclose(dst_file);

                        return 0;

                case 2: // 扩展段地址记录

                        addr_high = ((uint32_t)addr_low) << 2;

                        break;

                case 4: // 扩展线性地址记录

                        addr_high = ((uint32_t)addr_low) << 16;

                        break;

                default:

                        fclose(src_file);

                        fclose(dst_file);

                        return -1;

                }

        }

        fclose(src_file);

        fclose(dst_file);

        return 0;

}



int main(void)

{

        if (!hex2bin((const int8_t*)"avr-test.hex",(const int8_t*)"avr-test.bin"))

                printf("ok!\n");

        return 0;

}

要回复问题请先登录或注册

（转）keil生成的Hex和Bin的区别及hex转bin的源码

2 个回复

发起人

相关问题

问题状态

（转）keil生成的Hex和Bin的区别及hex转bin的源码

与内容相关的链接

2 个回复

发起人

相关问题

问题状态