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

一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得来。

/ i3 V1 h: w0 F8 i* U6 {二扩展地址

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

- ]" V8 d' d* W: s( c 第一行中，第一个字节为0x02，表示只有两个字节的数据，而扩展段的标识符为0x04表示后面的数据0x0800为扩展线性地址，基地址的计算方法为：

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

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

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

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

% o: S; G4 y0 B! N/ |三程序如何实现hex解析

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

头文件代码如下所示：

1. 
   * k" W1 O0 `% [
2. #ifndef _HEXLEXER_H_
   6 M( o2 g4 n) a7 Q; i2 ~( c
3. #define _HEXLEXER_H_
   
4. #include <cstdio>
   
5. #include <cstring>
   
6. #include <cstdlib>
   ( S3 Y7 l) q4 t- k6 c% j
7. /*
   3 X" x0 B! u! G( U
8. Intel Hex文件解析器V1.0
   
9. Hex文件的格式如下：
   : V, j' j3 C" L/ n( I
10. RecordMark  RecordLength  LoadOffset  RecordType  Data  Checksum
    
11. 在Intel Hex文件中，RecordMark规定为“:”
    - P' J( Y9 N0 ?+ _# d/ ^" u
12. */
    
13. #pragma warning(disable:4996)
    6 C2 u* P+ w0 x. z" @  ]1 M3 O
14. #define MAX_BUFFER_SIZE 43
    
15. class Hex
    
16. {
    % n* L; o: F2 R% F( C
17. public:
    # m* `" o1 s6 L1 k7 Q
18.   Hex(char mark);
    9 ?1 b/ y- q7 h
19.   ~Hex();
    
20.   void ParseHex(char *data);//解析Hex文件
    
21.   void ParseRecord(char ch);//解析每一条记录
    1 `+ a# ?* N6 {4 c# M4 i; ]) F
22.   size_t GetRecordLength();//获取记录长度
    & v& `4 M/ T, w! X1 z( b' h
23.   char GetRecordMark();//获取记录标识
    ( s' `8 e, {" M( z; s6 l1 F- g, s3 M
24.   char *GetLoadOffset();//获取内存装载偏移
    
25.   char *GetRecordType();//获取记录类型
    
26.   char *GetData();//获取数据
      [9 _2 o+ ?1 \3 }
27.   char *GetChecksum();//获取校验和
    9 i( g0 N: Y" B1 B& g
28.   
    
29. private:
    ) W* {4 S# _! e' P9 ^5 N  I3 U
30.   char m_cBuffer[MAX_BUFFER_SIZE];//存储待解析的记录
    
31.   char m_cRecordMark;//记录标识
    
32.   size_t m_nRecordLength;//记录长度
    
33.   char *m_pLoadOffset;//装载偏移
    
34.   char *m_pRecordType;//记录类型
    
35.   char *m_pData;//数据字段
    
36.   char *m_pChecksum;//校验和
    ; X9 i4 I  c1 w$ k9 o
37.   bool m_bRecvStatus;//接收状态标识
    
38.   //size_t m_nIndex;//缓存的字符索引值
    
39. };
    
40. 
    
41. Hex::Hex(char mark)
    
42. {
    
43.   this->m_cRecordMark = mark;
    ) R& L$ D& A! z# l5 C1 P' Z7 O
44.   m_cBuffer[0] = '\0';
    
45.   //m_pBuffer = NULL;
    3 O" t/ \8 [0 P+ \) x- ^
46.   m_nRecordLength = 0;
    
47.   m_pLoadOffset = NULL;
    
48.   m_pRecordType = NULL;
    
49.   m_pData = NULL;
    , E; d7 U6 A4 ?5 i
50.   m_pChecksum = NULL;
    
51.   m_bRecvStatus = false;
    
52.   //m_nIndex = 0;
    ! L1 V! s. R+ k# m! ?5 g% n9 T" y
53. }
    
54. 
    ' m0 o8 K$ b5 b6 ?  X" f/ S
55. Hex::~Hex()
    ' K: d' @5 l* o1 K. H" D8 t
56. {
    
57.   delete m_pLoadOffset, m_pRecordType, m_pData, m_pChecksum;
    0 A* O3 x5 s! z' _
58. }
    7 y9 [: K" Y! f0 ^
59. #endif

复制代码

! P+ n* D" K9 s  W; Z# A# |* T

代码如下所示。
3 k- |0 s) Y8 O$ N, B, {$ a- M

1. 
   ; B$ G$ Z5 c% y( b: V8 C% a" |
2. #include "HexLexer.h"
   
3. #include <iostream>
   . ]7 S; u9 \% O) R3 z5 C0 ?, N
4. using namespace std;
   
5. //获取记录标识
     P+ ?: n4 m; x
6. char Hex::GetRecordMark()
   
7. {
   4 o" h% P5 ]6 G, j+ r- ]3 y. f
8.   return this->m_cRecordMark;
   
9. }
   
10. //获取每条记录的长度
    # @# {/ K2 ?- q9 A/ A0 q* t
11. size_t Hex::GetRecordLength()
    ; u3 D  }1 L4 ?& V
12. {
    
13.   //char *len = (char*)malloc(sizeof(char)* 3);
    
14.   if (strlen(m_cBuffer)>=2)
    
15.   {
    & @9 z, B% [5 s4 U1 `; c
16.     char len[3];
    ! o( {" K& A# ?  O
17.     len[0] = m_cBuffer[0];
    : e; P' P- k' g+ D! N/ b1 N
18.     len[1] = m_cBuffer[1];
    * s7 w' ]: F! P) y& e9 |
19.     len[2] = '\0';
    
20.     char *p = NULL;
    8 |4 H* p- y6 ~7 E! \" P
21.     return strtol(len, &p, 16);
    ) {; O: ]5 I, C* [9 |! r
22.   }
    $ v* a. v, s; i( [! s
23.   else
    
24.   {
    
25.     return 0;
    
26.   }
      a, t9 f. K: L
27. }
    % D( C0 e) W' t  K" I3 R  Z) D+ \
28. //获取装载偏移
    8 i0 M" O, n2 j9 j. _# ~* w7 s
29. char* Hex::GetLoadOffset()
    
30. {
    5 x$ t. ~( J9 J) {
31.   if (strlen(m_cBuffer) == (GetRecordLength() + 5) * 2)
    ) i# U9 s# @( N7 Z/ c1 P0 o
32.   {
    
33.     char *offset = (char*)malloc(sizeof(char)* 5);
    8 ]& U( A. V6 B  ^: y2 m) u% r& o
34.     for (int i = 0; i < 4; ++i)
    , Y& z. n  G  e1 H) ^) _5 p" Y
35.     {
    
36.       offset[i] = m_cBuffer[i + 2];
    * F- N7 c. Y' v) C
37.     }
    
38.     offset[4] = '\0';
    
39.     m_pLoadOffset = offset;
    
40.     offset = NULL;
    
41.   }
    . T$ }' P+ \/ L" B5 V8 N
42.   return m_pLoadOffset;
    7 {  G8 J# C& o  W) c- ~" t
43. }
    ( A9 I$ A* y& n9 n/ G
44. //获取记录类型
    , L! a5 i$ M+ I- m$ e4 [
45. char* Hex::GetRecordType()
    4 B5 E( W$ N' [( |4 h
46. {
    " Z- @* }3 l0 q3 S, {
47.   if (strlen(m_cBuffer) == (GetRecordLength() + 5) * 2)
    ! _. o+ p! K) R- h" _
48.   {
    8 Q0 X! h, F3 F) M0 o: n1 B( a
49.     char *type=(char*)malloc(sizeof(char)*3);
    
50.     type[0] = m_cBuffer[6];
    
51.     type[1] = m_cBuffer[7];
    
52.     type[2] = '\0';
    
53.     m_pRecordType = type;
    
54.     type = NULL;
    1 T+ Y) I3 V, @7 R
55.   }
    ' G+ u4 v% o8 A. x, p+ w
56.   return m_pRecordType;
    + d$ a" b3 D( X
57. }
    * r' _8 G3 v( L& b% S* E0 w
58. //获取数据
    ( F+ a9 n( _6 r2 T: s" e) D
59. char* Hex::GetData()
    # @9 N7 A! T5 v+ `2 G( N4 h6 i, [
60. {
    
61.   if (strlen(m_cBuffer) == (GetRecordLength() + 5) * 2)
    % l- ?9 @# z3 K5 ?5 H9 l6 R6 g( s
62.   {
    . O; k$ A/ p5 w, R
63.     int len = GetRecordLength();
    3 q2 ]7 l- \. ]1 g/ C" ?+ H8 ?
64.     char *data = (char*)malloc(sizeof(char)*(len * 2 + 1));
    
65.     for (int i = 0; i < len * 2;++i)
    + k- N8 _7 C' O; s2 D5 ?9 a8 Q1 [
66.     {
    , r" O' E1 V2 e* f( g
67.       data[i] = m_cBuffer[i + 8];
    
68.     }
    ( i. H2 P( G; d
69.     data[len * 2] = '\0';
    5 f3 F2 d% d# n. I1 J
70.     m_pData = data;
    ) q0 J5 H+ X# L. r- f6 M/ @7 I
71.     data = NULL;
    2 I  _" F$ p- T
72.   }
    
73.   return m_pData;
    
74. }
    " o' I. Y7 o1 h5 Q1 V. I$ ]7 l, [6 Z
75. //获取校验和
    
76. char* Hex::GetChecksum()
    
77. {
    
78.   int len = GetRecordLength();
    
79.   if (strlen(m_cBuffer) == (len + 5) * 2)
    
80.   {
    
81.     char *checksum=(char*)malloc(sizeof(char)*3);
    % ?7 E2 T( |9 f8 e9 b/ k
82.     checksum[0] = m_cBuffer[(len + 5) * 2 - 2];
    
83.     checksum[1] = m_cBuffer[(len + 5) * 2-1];
    
84.     checksum[2] = '\0';
    
85.     m_pChecksum = checksum;
    
86.     checksum=NULL;
    3 @4 c& r" _# K
87.   }
    7 \6 W+ R$ [. I3 d. T
88.   return m_pChecksum;
    
89. }
    : i; u  X$ j% N$ g  L2 D
90. //解析Hex文件中的每一条记录
    
91. void Hex::ParseRecord(char ch)
    2 ^9 c( j4 _* U0 u
92. {
    / q# p# K* \/ r
93.   size_t buf_len = strlen(m_cBuffer);
    4 H* V) l# v/ r& f4 H
94.   if (GetRecordMark()==ch)
    
95.   {
    
96.     m_bRecvStatus = true;
    
97.     m_cBuffer[0] = '\0';
    
98.     //m_nIndex = 0;
    
99.     return;
    
100.   }
     8 j/ [* G5 O' V- q
101.   if ((buf_len==(GetRecordLength()+5)*2-1))
     
102.   {
     ) H- T! M, Y. w1 {
103.     //接收最后一个字符
     6 t. m: f- B: z& P! ?
104.     m_cBuffer[buf_len] = ch;
     
105.     m_cBuffer[buf_len + 1] = '\0';
     
106.     //检验接收的数据
     
107.     char temp[3];
     
108.     char *p = NULL;
     4 W/ e+ ]# P5 h6 i* I) _* }) E% T
109.     long int checksum = 0;
     - @0 C* ?0 ?/ r$ k
110.     for (int i = 0; i < strlen(m_cBuffer);i+=2)
     $ X" `9 B$ C% n1 g
111.     {
     ) ^7 [3 D. ~( }# N. R, ]
112.       temp[0] = m_cBuffer[i];
     1 k8 `+ a8 H  R; A- \
113.       temp[1] = m_cBuffer[i + 1];
     ) c+ I9 a! l8 V0 j( U: P
114.       temp[2] = '\0';
       ?8 r8 Z; l) G4 a9 v. S# f
115.       checksum += strtol(temp, &p, 16);
     
116.       temp[0] = '\0';
     2 _" k1 J8 k, s. L! P; u* }# _: d2 k
117.     }
     
118.     checksum &= 0x00ff;//取计算结果的低8位
     7 t6 T+ n/ O0 q( c* K: R' s
119.     if (checksum==0)//checksum为0说明接收的数据无误
     
120.     {
     
121.       cout << "RecordMark " << GetRecordMark() << endl;
     8 k/ G) b, p3 }7 d
122.       cout << "RecordLength " << GetRecordLength() << endl;
     5 ~8 w) W6 I9 c; O9 U! k' a
123.       cout << "LoadOffset " << GetLoadOffset() << endl;
       j: o, v) d/ y  i
124.       cout << "RecordType " << GetRecordType() << endl;
     ! R# H' T- Q' L7 v
125.       cout << "Data " << GetData() << endl;
     ( k: N5 q" D6 H0 `
126.       cout << "Checksum " << GetChecksum() << endl;
     ! r$ Z6 w9 h  O' H' |/ Q. x) q" b
127.     }
     ( v8 L1 f# n( F7 A% n
128.     else//否则接收数据有误
     : [; C8 A0 p$ s
129.     {
     
130.       cout << "Error!" << endl;
     
131.     }
     7 o( _8 r- l' g. h5 M, i
132.     m_cBuffer[0] = '\0';
     
133.     m_bRecvStatus = false;
     
134.     m_nRecordLength = 0;
     
135.     m_pLoadOffset = NULL;
     % T( k& m1 t& X3 g' L3 N
136.     m_pRecordType = NULL;
     
137.     m_pChecksum = NULL;
     
138.     m_bRecvStatus = false;
     4 M0 @& Z0 x$ W
139.   }
     
140.   else if (m_bRecvStatus)
     + t0 c! _% h# h; s) m
141.   {
     8 |. M$ j6 |. S0 {7 u0 F
142.     m_cBuffer[buf_len] = ch;
       Q  h+ q( l% H" t* h6 u
143.     m_cBuffer[buf_len + 1] = '\0';
     
144.     //m_nIndex++;
     
145.   }
     3 A3 s6 V- R4 |! s7 F$ `. ~' _1 `3 E
146. }
     ) R7 m; h3 p) u. C
147. //解析Hex文件
     
148. void Hex::ParseHex(char *data)
     : d) _( o# `) U& n" L
149. {
     / o* [) {* V) J% s( B) l+ m
150.   for (int i = 0; i < strlen(data);++i)
     
151.   {
     
152.     ParseRecord(data[i]);
     
153.   }
     2 V7 U7 b8 ]  g. Z
154. }
     
155. int main(int argc, char *argv[])
     5 t  h0 j4 w! m3 J/ [3 @
156. {
     ) M! i+ A, C- h' T
157.   freopen("in.txt", "r", stdin);
     0 O1 V$ \% i1 a( n& r
158.   freopen("out.txt", "w", stdout);
     5 e9 k; y" @7 ]8 T" Q
159. 
     
160.   Hex hex(':');
     ! ]& [7 r; d3 W5 i$ z! E' M
161.   char ch;
     0 T$ K8 g9 |" J- k/ d  T
162.   while (cin>>ch)
     / X4 m# ]; ~5 C
163.   {
     $ [( ~& k5 m# s  ~1 m. p
164.     hex.ParseRecord(ch);
     5 A2 i8 v4 a2 k. I) Z! ~; C
165.   }
     + w/ ^# x1 C4 \5 [
166.   fclose(stdout);
     * j! s9 D; k/ [% d9 p- ~8 N2 m8 H
167.   fclose(stdin);
     ; Y& ?7 ^- Z; Q6 L+ r: p! ]
168.   return 0;
     - F( `# q& H! O7 t" j- Y
169. }

复制代码

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

7 w7 w# x6 b# ?/ X+ g: w

mark~~~~~

不错