含有单片机的电子产品在量产的时候会用到.hex文件或者.bin。hex是十六进制的，包含地址信息和数据信息，而bin文件是二进制的，只有数据而不包含地址。任何文件都有一定的格式规范，hex文件同样具有完整的格式规范。今天和大家分享一下，hex是如何解析的。

1 c& d3 i8 q- Q# C

一hex文件解析

hex文件可以通过UltraEdit、Notepad++、记事本等工具打开，用Notepad++打开之后会看到如下数据内容。

使用Notepad++打开后会不同含义的数据其颜色不同。每行数据都会有一个冒号开始，后面的数据由：数据长度、地址、标识符、有效数据、校验数据等构成。以上图的第一行为例，进行解析：

第1个字节10，表示该行具有0x10个数据，即16个字节的数据；

第2、3个字节C000，表示该行的起始地址为0xC000；

第4个字节00，表示该行记录的是数据；

第5-20个字节，表示的是有效数据；

第21个字节73，表示前面数据的校验数据，校验方法：0x100-前面字节累加和；

其中，第4个字节具有5种类型：00-05，含义如下：

字段	含义
00	表示后面记录的是数据
01	表示文件结束
02	表示扩展段地址
03	表示开始段地址
04	表示扩展线性地址
05	表示开始线性地址

单片机的hex文件以00居多，都用来表示数据。hex文件的结束部分如下图所示。

最后一行的01表示文件结束了，最后的FF表示校验数据，由0x100-0x01=0xFF得来。
+ x& ^) T7 F& M0 o2 F2 o

2 B, ^4 T1 E4 ]二扩展地址

细心的同学可能发现了，上面的地址都是两个字节，范围从0x000-0xFFFF，如果地址是0x17FFFF该怎么办呢？这就要用到扩展字段了，举例如下：

$ ?8 r6 v& D- \8 b 第一行中，第一个字节为0x02，表示只有两个字节的数据，而扩展段的标识符为0x04表示后面的数据0x0800为扩展线性地址，基地址的计算方法为：

(0x0800<<16)=0x08000000，在0x04标识段出现之前，下面的数据都是这个基地址。

第二行的地址是0x0000，那么实际地址应是0x08000000+0x0000=0x08000000；

第二行的地址是0x0010，那么实际地址应是0x08000000+0x0010=0x08000010；

使用Notepad++工具，可以根据颜色的不同来确认校验数据是否正确，如果校验数据的颜色不是绿色，则表示校验结果是错的。

. U) T1 ]! u1 v$ D$ h5 P三程序如何实现hex解析

经常会用到上位机软件来实现单片机的烧录，那上位机就要解析hex文件，程序如何实现hex文件的解析呢？

头文件代码如下所示：

1. 
   " E/ @) z! j' ^; K" \- k8 ]
2. #ifndef _HEXLEXER_H_
   
3. #define _HEXLEXER_H_
   $ k$ {  |8 t5 J, p
4. #include <cstdio>
   
5. #include <cstring>
   
6. #include <cstdlib>
   + L4 {; N* t$ _. r- |
7. /*
   
8. Intel Hex文件解析器V1.0
   
9. Hex文件的格式如下：
   
10. RecordMark  RecordLength  LoadOffset  RecordType  Data  Checksum
    
11. 在Intel Hex文件中，RecordMark规定为“:”
    
12. */
    
13. #pragma warning(disable:4996)
    % `) x  Y' z. R! |' D3 @5 o9 b
14. #define MAX_BUFFER_SIZE 43
    : q7 K( Y% z$ b( U" x% G$ U) g3 _
15. class Hex
    , f4 i. l! B* Q
16. {
    
17. public:
    
18.   Hex(char mark);
    1 S2 H% J! o( J6 c5 c, R0 z" }9 P
19.   ~Hex();
    ' K# S$ }% w) G* R$ s) A! }' N( B# W
20.   void ParseHex(char *data);//解析Hex文件
    
21.   void ParseRecord(char ch);//解析每一条记录
    
22.   size_t GetRecordLength();//获取记录长度
    ; u4 x. H; n2 k' L) f
23.   char GetRecordMark();//获取记录标识
    
24.   char *GetLoadOffset();//获取内存装载偏移
    
25.   char *GetRecordType();//获取记录类型
    4 _. @% R' P( [3 m, D
26.   char *GetData();//获取数据
    
27.   char *GetChecksum();//获取校验和
    
28.   
    
29. private:
    
30.   char m_cBuffer[MAX_BUFFER_SIZE];//存储待解析的记录
    
31.   char m_cRecordMark;//记录标识
    
32.   size_t m_nRecordLength;//记录长度
    7 R' @3 m/ h. Z
33.   char *m_pLoadOffset;//装载偏移
    9 A2 @; h7 p" e& I- f6 E, W2 d
34.   char *m_pRecordType;//记录类型
    
35.   char *m_pData;//数据字段
    0 v& ]2 {  V" ]8 }, w. E6 ~
36.   char *m_pChecksum;//校验和
    $ k9 ^1 ~  ^$ u
37.   bool m_bRecvStatus;//接收状态标识
    + y- G! K7 G( }
38.   //size_t m_nIndex;//缓存的字符索引值
    
39. };
    
40. 
    ( G7 M" n6 r$ G# ^1 }- I
41. Hex::Hex(char mark)
    ! h$ u8 o& O- c" V/ B1 ~( a
42. {
    / [2 H0 B7 ?  M
43.   this->m_cRecordMark = mark;
    
44.   m_cBuffer[0] = '\0';
    2 s# ?% t4 J: e
45.   //m_pBuffer = NULL;
    
46.   m_nRecordLength = 0;
    " A, B+ F3 ~8 Z9 ^1 t
47.   m_pLoadOffset = NULL;
    
48.   m_pRecordType = NULL;
    
49.   m_pData = NULL;
    
50.   m_pChecksum = NULL;
    
51.   m_bRecvStatus = false;
    
52.   //m_nIndex = 0;
    
53. }
    8 [4 K( d! X/ q- L( N6 u4 M  y) |
54. 
    
55. Hex::~Hex()
    ! X9 |/ d' N  b
56. {
    8 D5 L' C4 v+ K, l) P
57.   delete m_pLoadOffset, m_pRecordType, m_pData, m_pChecksum;
    ' \' i& I) b8 t7 z4 L
58. }
    
59. #endif

复制代码

代码如下所示。
; ?/ a9 T* I0 X* `- @4 C" o9 J9 l( r

1. 
   ; {' L* S& F, G" }( L# Y% k0 K6 X
2. #include "HexLexer.h"
   
3. #include <iostream>
   % f" o9 ?4 W* y0 Q' a2 P
4. using namespace std;
   ( c7 Z, r. n7 _. ~& _" P4 s/ a- @
5. //获取记录标识
   
6. char Hex::GetRecordMark()
   3 Y' f1 z9 M$ U+ `: A$ T
7. {
   : C/ C- o9 H. W9 B: L; Q& {( u
8.   return this->m_cRecordMark;
   
9. }
   6 C- i$ l" k) i/ P$ I0 D; I
10. //获取每条记录的长度
    
11. size_t Hex::GetRecordLength()
    ' \$ `8 R& Q, E6 d1 a. a7 q' G, q
12. {
    
13.   //char *len = (char*)malloc(sizeof(char)* 3);
    6 \1 E9 S0 U& W4 T. E
14.   if (strlen(m_cBuffer)>=2)
    
15.   {
    
16.     char len[3];
    
17.     len[0] = m_cBuffer[0];
    
18.     len[1] = m_cBuffer[1];
    
19.     len[2] = '\0';
    
20.     char *p = NULL;
    ) Y8 z- H0 ]& v+ L3 b7 K8 A
21.     return strtol(len, &p, 16);
    % _  X/ J0 {* r% z+ C1 S
22.   }
    
23.   else
    
24.   {
    
25.     return 0;
    , a' o6 o  x& \
26.   }
    
27. }
    , f3 j. P2 A! M* _7 E
28. //获取装载偏移
    
29. char* Hex::GetLoadOffset()
    
30. {
    5 ]. }% B; _' Z4 n& U; R' Q" z
31.   if (strlen(m_cBuffer) == (GetRecordLength() + 5) * 2)
      {: z/ |+ C* q( d
32.   {
    
33.     char *offset = (char*)malloc(sizeof(char)* 5);
    
34.     for (int i = 0; i < 4; ++i)
    / S; T2 e; ~8 P1 k6 }
35.     {
    
36.       offset[i] = m_cBuffer[i + 2];
    ' M# s6 U8 N( u( U2 V
37.     }
    " C0 @' D) [2 q/ d. y2 C/ v
38.     offset[4] = '\0';
    
39.     m_pLoadOffset = offset;
    
40.     offset = NULL;
    " U9 S) u, q) M1 o
41.   }
    
42.   return m_pLoadOffset;
    ! n5 m* v/ O% ~
43. }
    + v9 J/ {: b% P
44. //获取记录类型
    
45. char* Hex::GetRecordType()
    
46. {
    
47.   if (strlen(m_cBuffer) == (GetRecordLength() + 5) * 2)
    
48.   {
    3 q' X5 N% f* v- A
49.     char *type=(char*)malloc(sizeof(char)*3);
    
50.     type[0] = m_cBuffer[6];
    8 E/ q% Z( H: N6 H
51.     type[1] = m_cBuffer[7];
    
52.     type[2] = '\0';
    
53.     m_pRecordType = type;
    
54.     type = NULL;
    
55.   }
    " `. Z+ S1 E$ E
56.   return m_pRecordType;
    
57. }
    3 D# d5 V: a; X# ^
58. //获取数据
    
59. char* Hex::GetData()
    
60. {
    " x2 P. ~5 o' p0 s" M& t0 u
61.   if (strlen(m_cBuffer) == (GetRecordLength() + 5) * 2)
    
62.   {
    
63.     int len = GetRecordLength();
    
64.     char *data = (char*)malloc(sizeof(char)*(len * 2 + 1));
    ! H: A, s/ Z3 ^1 g; @
65.     for (int i = 0; i < len * 2;++i)
    
66.     {
    
67.       data[i] = m_cBuffer[i + 8];
    7 X) O: L% @7 {/ k
68.     }
    / q) a4 m$ m  W/ G
69.     data[len * 2] = '\0';
    
70.     m_pData = data;
    ) n+ `. a' m, Q+ T
71.     data = NULL;
    $ ~0 F. p6 W4 G9 `
72.   }
    * z! `( `3 J" [$ i  o) [# l4 t- s; M2 D
73.   return m_pData;
    7 y& C: z$ @  f% b7 i4 N5 _4 D
74. }
    
75. //获取校验和
    : o) d/ B, h. W! `. h8 L* V
76. char* Hex::GetChecksum()
    # I/ c0 h9 ~' K+ F+ \' i- C% K
77. {
    9 x3 k& t. }7 [. O6 j
78.   int len = GetRecordLength();
    / `% C2 e  c  t2 b) }1 b7 F
79.   if (strlen(m_cBuffer) == (len + 5) * 2)
    0 V8 Y. a8 z  F
80.   {
    
81.     char *checksum=(char*)malloc(sizeof(char)*3);
    
82.     checksum[0] = m_cBuffer[(len + 5) * 2 - 2];
    
83.     checksum[1] = m_cBuffer[(len + 5) * 2-1];
    ( d6 z4 I! ^7 N% w. h
84.     checksum[2] = '\0';
    & U$ b4 ^4 i8 N
85.     m_pChecksum = checksum;
    ! K0 x/ w/ T; i! O1 u/ @/ z( T
86.     checksum=NULL;
    
87.   }
    ( _5 g6 A- ]7 T( F
88.   return m_pChecksum;
    
89. }
    
90. //解析Hex文件中的每一条记录
    
91. void Hex::ParseRecord(char ch)
    
92. {
    
93.   size_t buf_len = strlen(m_cBuffer);
    1 K6 z, m# T( C) o6 B# W, J8 t, ^
94.   if (GetRecordMark()==ch)
    ( \8 e8 H/ j7 y2 p# |  @3 p4 ~
95.   {
    
96.     m_bRecvStatus = true;
    
97.     m_cBuffer[0] = '\0';
    ! f. }; ], F' l8 I
98.     //m_nIndex = 0;
    
99.     return;
    
100.   }
     
101.   if ((buf_len==(GetRecordLength()+5)*2-1))
     
102.   {
     
103.     //接收最后一个字符
     
104.     m_cBuffer[buf_len] = ch;
     0 F# k7 @4 ~* c% H4 h+ |
105.     m_cBuffer[buf_len + 1] = '\0';
     1 V. P2 h& C# E) f: e/ d2 u
106.     //检验接收的数据
     
107.     char temp[3];
     
108.     char *p = NULL;
     
109.     long int checksum = 0;
     2 k6 Q+ S6 |( z9 S( q  r( N' e( ?
110.     for (int i = 0; i < strlen(m_cBuffer);i+=2)
     ! N  j/ |6 @4 h( }$ I' j
111.     {
     2 _, b2 r1 G$ t7 Z$ M; L
112.       temp[0] = m_cBuffer[i];
     
113.       temp[1] = m_cBuffer[i + 1];
     / e0 O% V9 ~/ J) t
114.       temp[2] = '\0';
     3 j# h! _( G  T- w
115.       checksum += strtol(temp, &p, 16);
     
116.       temp[0] = '\0';
     * h, {5 `5 c6 z* L% F7 u- ^
117.     }
     
118.     checksum &= 0x00ff;//取计算结果的低8位
     2 h, S- d% ^1 [$ T4 R, x0 Y' y) T! n
119.     if (checksum==0)//checksum为0说明接收的数据无误
     & y% _/ S# ^( b4 T$ N1 B
120.     {
     
121.       cout << "RecordMark " << GetRecordMark() << endl;
     5 B5 v+ Q/ n5 o  O
122.       cout << "RecordLength " << GetRecordLength() << endl;
     
123.       cout << "LoadOffset " << GetLoadOffset() << endl;
     
124.       cout << "RecordType " << GetRecordType() << endl;
     + `6 E7 k" O' Q7 V- f" u0 G
125.       cout << "Data " << GetData() << endl;
     " }( O+ \9 T8 k% F1 P2 J
126.       cout << "Checksum " << GetChecksum() << endl;
     
127.     }
     
128.     else//否则接收数据有误
     
129.     {
     
130.       cout << "Error!" << endl;
     
131.     }
     + H3 N. t2 V/ ?7 H5 Y, W
132.     m_cBuffer[0] = '\0';
     ; C+ ]& e& L9 \8 j" n4 y/ G
133.     m_bRecvStatus = false;
     . u8 S4 L* k  x9 A2 B
134.     m_nRecordLength = 0;
     & e: m# H$ A# w5 q
135.     m_pLoadOffset = NULL;
     
136.     m_pRecordType = NULL;
     * z) q; @; r  N9 u
137.     m_pChecksum = NULL;
     9 m$ x0 s# p  Q) W
138.     m_bRecvStatus = false;
     - |3 _9 t* w  H; d7 J3 A& V4 E
139.   }
     
140.   else if (m_bRecvStatus)
     
141.   {
     
142.     m_cBuffer[buf_len] = ch;
     5 A) [7 T4 F+ D0 Q, \
143.     m_cBuffer[buf_len + 1] = '\0';
     - c" I" \/ n7 P, J3 n' ~
144.     //m_nIndex++;
     
145.   }
     
146. }
     
147. //解析Hex文件
     
148. void Hex::ParseHex(char *data)
     6 Y* R9 H5 ]5 y4 ~8 w  u# P' L# R: C
149. {
     7 O) S  p) `; t; G) v. n1 @
150.   for (int i = 0; i < strlen(data);++i)
     
151.   {
     ( F- {% X  s( F, ?& \; j# ?% V
152.     ParseRecord(data[i]);
     & [, ^! B4 G. f- P8 F4 g* o& S
153.   }
     
154. }
     1 O: c: ^7 P* `, E
155. int main(int argc, char *argv[])
     & m6 W) A% _9 k: \
156. {
     
157.   freopen("in.txt", "r", stdin);
     ! G# Z4 g2 ?( M
158.   freopen("out.txt", "w", stdout);
     & t, K) I2 G" T0 ^7 t
159. 
       S$ `8 Q. V% w# R1 {" |2 t5 d
160.   Hex hex(':');
     1 A5 P8 N& w+ r$ o
161.   char ch;
     . t9 O2 S& o+ {6 J, \
162.   while (cin>>ch)
     # n& f( K' X/ F, m- T& z, W
163.   {
     
164.     hex.ParseRecord(ch);
     
165.   }
     6 h$ _$ A* d# n6 Y: l
166.   fclose(stdout);
     
167.   fclose(stdin);
     
168.   return 0;
     ! C* ?# z/ D* W+ n; \4 C
169. }

复制代码

* y% c& G; b+ X! S

是不是这样呢？赶紧打开.hex文件来看一下吧。

2 w5 F% G. P) [& p

mark~~~~~

不错