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

3 ]1 S, [: L8 T+ H& u! N$ h

/ R  b1 O5 c+ B$ g一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得来。
' z2 y7 [2 P8 P$ r8 \1 V

6 _6 M* e( ?/ v+ J0 D

二扩展地址

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

5 h) B& V' N+ O2 w% ` 第一行中，第一个字节为0x02，表示只有两个字节的数据，而扩展段的标识符为0x04表示后面的数据0x0800为扩展线性地址，基地址的计算方法为：

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

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

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

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

5 r: o" ~4 s, w4 G1 R3 d7 M

三程序如何实现hex解析

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

  }( ^+ a! @9 ]1 I4 y: U

头文件代码如下所示：

1. 
   
2. #ifndef _HEXLEXER_H_
   
3. #define _HEXLEXER_H_
   
4. #include <cstdio>
   
5. #include <cstring>
   . ?8 J& b& j& |2 n" v9 B5 P
6. #include <cstdlib>
   
7. /*
   
8. Intel Hex文件解析器V1.0
   
9. Hex文件的格式如下：
   
10. RecordMark  RecordLength  LoadOffset  RecordType  Data  Checksum
    
11. 在Intel Hex文件中，RecordMark规定为“:”
    : d5 ^7 ], h5 o
12. */
    $ c" l1 k( i' P. P/ C6 S
13. #pragma warning(disable:4996)
    
14. #define MAX_BUFFER_SIZE 43
    
15. class Hex
    
16. {
    
17. public:
    8 [- v- i# l: Y2 c7 @
18.   Hex(char mark);
    % k* R4 B  ]0 i- m' n& o1 z  l
19.   ~Hex();
    
20.   void ParseHex(char *data);//解析Hex文件
    & M* N* x0 @; ?- e
21.   void ParseRecord(char ch);//解析每一条记录
    
22.   size_t GetRecordLength();//获取记录长度
    
23.   char GetRecordMark();//获取记录标识
    
24.   char *GetLoadOffset();//获取内存装载偏移
    
25.   char *GetRecordType();//获取记录类型
    / V+ K+ t2 S  h/ B1 K0 p" i
26.   char *GetData();//获取数据
    3 c' @3 ~- K" j0 _1 ~( l
27.   char *GetChecksum();//获取校验和
    
28.   
    ) i9 q# @  K* F3 @( n# W
29. private:
    
30.   char m_cBuffer[MAX_BUFFER_SIZE];//存储待解析的记录
    
31.   char m_cRecordMark;//记录标识
    - H. V" v! K/ j7 J; d
32.   size_t m_nRecordLength;//记录长度
    ( @* z1 |' Y6 d- _/ i
33.   char *m_pLoadOffset;//装载偏移
    
34.   char *m_pRecordType;//记录类型
    
35.   char *m_pData;//数据字段
    7 N3 I% J( B/ j/ k0 }6 t" M
36.   char *m_pChecksum;//校验和
    % g; f9 {1 M4 {9 A  a3 u, t! `! y
37.   bool m_bRecvStatus;//接收状态标识
    7 o1 z% {) M7 @% A7 |2 P9 G+ Z
38.   //size_t m_nIndex;//缓存的字符索引值
    ) \$ W7 p4 P) ^0 l" {) {
39. };
    : V: @; V' _. g% ~
40. 
    # @9 n- j( E& L) W
41. Hex::Hex(char mark)
    
42. {
    
43.   this->m_cRecordMark = mark;
    
44.   m_cBuffer[0] = '\0';
    
45.   //m_pBuffer = NULL;
    
46.   m_nRecordLength = 0;
    
47.   m_pLoadOffset = NULL;
    2 y) d  r) t" e/ O+ h$ R" I& I7 t
48.   m_pRecordType = NULL;
    , H( z# O( y9 u' f( x
49.   m_pData = NULL;
    
50.   m_pChecksum = NULL;
    9 s3 w: l3 H" E. Q* M
51.   m_bRecvStatus = false;
    7 S  E6 z4 Z; B/ W+ j
52.   //m_nIndex = 0;
    
53. }
    
54. 
    9 I& ~9 z! x; f
55. Hex::~Hex()
    6 N% i- Z. n0 j- Q; k
56. {
    
57.   delete m_pLoadOffset, m_pRecordType, m_pData, m_pChecksum;
    + z2 n. q1 {: N5 |  T
58. }
    
59. #endif

复制代码

代码如下所示。
, R. t1 L9 M" Q: \9 n: z# ?

1. 
   ( F- x2 H& a, l
2. #include "HexLexer.h"
   9 y4 n) }* L0 |
3. #include <iostream>
   
4. using namespace std;
   
5. //获取记录标识
   
6. char Hex::GetRecordMark()
   4 R, ]- F& c8 X0 h7 I. Q* p) N: m
7. {
   ) y& k" v' n: y4 h& |
8.   return this->m_cRecordMark;
   1 X. N7 o: L7 W( S
9. }
   
10. //获取每条记录的长度
    & E5 `7 Q4 W5 Y
11. size_t Hex::GetRecordLength()
    3 j7 y5 M/ }1 y$ J* I* d  P2 y
12. {
    
13.   //char *len = (char*)malloc(sizeof(char)* 3);
    
14.   if (strlen(m_cBuffer)>=2)
    
15.   {
    - H" Z* e* ]5 c* z& o
16.     char len[3];
    & R1 N$ }( `2 |7 K1 N4 {5 K( n
17.     len[0] = m_cBuffer[0];
    ! Y2 h9 m! [* M
18.     len[1] = m_cBuffer[1];
    : J6 Q7 ^# F1 Q/ I
19.     len[2] = '\0';
    8 g- w7 e$ P/ o, x
20.     char *p = NULL;
    
21.     return strtol(len, &p, 16);
    
22.   }
    
23.   else
    
24.   {
    # `( K4 l6 W1 D/ N/ Y+ R' l
25.     return 0;
    
26.   }
    9 p/ z1 M" B. Y# v( G8 t
27. }
    
28. //获取装载偏移
    : e. ~; k. X/ o. _" U' X  H
29. char* Hex::GetLoadOffset()
    
30. {
    
31.   if (strlen(m_cBuffer) == (GetRecordLength() + 5) * 2)
    8 u4 \+ k9 R1 T. ~
32.   {
    # y0 o# ?/ i6 x' S: Z& R
33.     char *offset = (char*)malloc(sizeof(char)* 5);
    
34.     for (int i = 0; i < 4; ++i)
    
35.     {
    7 a, E2 a3 v1 I, U! W- ]
36.       offset[i] = m_cBuffer[i + 2];
    3 h5 E# h* m+ v$ v* c0 a8 E* Y0 G
37.     }
    
38.     offset[4] = '\0';
    * H6 k- m! j+ k" S
39.     m_pLoadOffset = offset;
    + A4 E* u, ~( K! `) x" F- \/ ^
40.     offset = NULL;
    
41.   }
    1 O; R$ B8 C" q' t
42.   return m_pLoadOffset;
    
43. }
    ) B1 b2 w+ u7 t) L: r8 y3 p  u
44. //获取记录类型
    
45. char* Hex::GetRecordType()
    
46. {
    
47.   if (strlen(m_cBuffer) == (GetRecordLength() + 5) * 2)
    4 L& j; u8 F5 X5 F9 @( ~8 m3 E1 Y8 I
48.   {
    
49.     char *type=(char*)malloc(sizeof(char)*3);
    ' y) _/ g5 ~, z9 z2 V# X
50.     type[0] = m_cBuffer[6];
    # i! D8 i$ x! t- p6 T" j1 U
51.     type[1] = m_cBuffer[7];
    ! h$ Z# [3 m9 p
52.     type[2] = '\0';
    " t  P1 ]! R) x5 W
53.     m_pRecordType = type;
    8 _/ A7 J% j: F+ f) _' C
54.     type = NULL;
    . i( R+ ?+ u7 R. F
55.   }
    
56.   return m_pRecordType;
    , H3 A" z; O9 J# w  I& R3 {/ V1 p
57. }
    
58. //获取数据
    , H, r* N$ |  i/ {1 m1 u' |( E
59. char* Hex::GetData()
    
60. {
    8 g$ L( _8 _: z. V; `
61.   if (strlen(m_cBuffer) == (GetRecordLength() + 5) * 2)
    2 i# C& K9 A* U7 G! M( ]
62.   {
    
63.     int len = GetRecordLength();
    
64.     char *data = (char*)malloc(sizeof(char)*(len * 2 + 1));
    5 G# B" k) G0 R$ D* c- E% F
65.     for (int i = 0; i < len * 2;++i)
    : p0 Z, V! n- E' ?! u/ e3 w
66.     {
    
67.       data[i] = m_cBuffer[i + 8];
    6 C, L7 |& x+ `0 T
68.     }
    + j4 g+ X) o: u, C3 i- _: D
69.     data[len * 2] = '\0';
    # a, [" o% h- h2 x# h
70.     m_pData = data;
    ) N: n1 t+ `1 U$ W: V6 r; i0 k
71.     data = NULL;
    . o5 t5 @! d1 Y
72.   }
    
73.   return m_pData;
    
74. }
    
75. //获取校验和
    ! ^& c; O9 A; W+ s
76. char* Hex::GetChecksum()
    
77. {
    
78.   int len = GetRecordLength();
    
79.   if (strlen(m_cBuffer) == (len + 5) * 2)
    3 v) R' ^( B$ S
80.   {
    
81.     char *checksum=(char*)malloc(sizeof(char)*3);
    . J7 S# l1 W% i
82.     checksum[0] = m_cBuffer[(len + 5) * 2 - 2];
    
83.     checksum[1] = m_cBuffer[(len + 5) * 2-1];
    ! L( i7 V& ?& S2 v- A1 h
84.     checksum[2] = '\0';
    
85.     m_pChecksum = checksum;
    ( t1 e; z' i( {7 b
86.     checksum=NULL;
    
87.   }
    
88.   return m_pChecksum;
    
89. }
    
90. //解析Hex文件中的每一条记录
    
91. void Hex::ParseRecord(char ch)
    
92. {
    
93.   size_t buf_len = strlen(m_cBuffer);
    / {) o) u2 N* d( V7 x) j
94.   if (GetRecordMark()==ch)
    5 o6 \! W" L! |, Q# Z6 f; x
95.   {
    
96.     m_bRecvStatus = true;
    
97.     m_cBuffer[0] = '\0';
    5 d, b" [4 s$ W
98.     //m_nIndex = 0;
    7 c+ ~4 N, p' X
99.     return;
    3 \, C, b; I; V, X2 R5 z
100.   }
     
101.   if ((buf_len==(GetRecordLength()+5)*2-1))
     
102.   {
     0 i9 }: O3 w: Y, t$ I. P
103.     //接收最后一个字符
     ( C* ~# P3 v: U" U  W
104.     m_cBuffer[buf_len] = ch;
       o* s5 u5 w! Q" y& f$ s1 T# B" a
105.     m_cBuffer[buf_len + 1] = '\0';
     / m: k+ J1 o: Q( q0 ~- {
106.     //检验接收的数据
     / ]) ^3 z& E# O
107.     char temp[3];
       \  }, h0 E2 i* ^! l7 f
108.     char *p = NULL;
     : D* m+ S( P% c5 s& X
109.     long int checksum = 0;
     " [1 m# a2 _" e9 m  |( Q  q
110.     for (int i = 0; i < strlen(m_cBuffer);i+=2)
     
111.     {
     
112.       temp[0] = m_cBuffer[i];
     0 y0 |7 [8 y9 i" [
113.       temp[1] = m_cBuffer[i + 1];
     0 @( l* w4 ^. H, p" l$ `! h+ k# D
114.       temp[2] = '\0';
     $ R: l7 b8 @* g) p+ p* O: J  s& y
115.       checksum += strtol(temp, &p, 16);
     / ]' s' Y- B5 G7 {( P* `
116.       temp[0] = '\0';
     
117.     }
     ; `6 m4 g, ]! U2 G8 p
118.     checksum &= 0x00ff;//取计算结果的低8位
     1 ~' f4 l% v3 o) h+ N+ s8 }% h
119.     if (checksum==0)//checksum为0说明接收的数据无误
     
120.     {
     8 L2 q# o+ l; v! h+ {6 p5 D5 g
121.       cout << "RecordMark " << GetRecordMark() << endl;
     
122.       cout << "RecordLength " << GetRecordLength() << endl;
     7 ~  [. X  B, w# \8 z" t
123.       cout << "LoadOffset " << GetLoadOffset() << endl;
     0 h. l0 a9 t4 y; S* o' b
124.       cout << "RecordType " << GetRecordType() << endl;
     
125.       cout << "Data " << GetData() << endl;
     
126.       cout << "Checksum " << GetChecksum() << endl;
       X- d/ p) y; F7 L4 {/ ^, ]6 \  n
127.     }
     / E& M* g2 h( V
128.     else//否则接收数据有误
     
129.     {
     
130.       cout << "Error!" << endl;
     % H7 n* z8 u& m
131.     }
     
132.     m_cBuffer[0] = '\0';
     
133.     m_bRecvStatus = false;
     5 P8 ~4 {3 w! T1 Q
134.     m_nRecordLength = 0;
     ; w5 a/ E% [! y' V
135.     m_pLoadOffset = NULL;
     
136.     m_pRecordType = NULL;
     
137.     m_pChecksum = NULL;
     0 q( s) x5 C2 T3 B
138.     m_bRecvStatus = false;
     
139.   }
     ! y' e5 R3 `3 z0 K6 P
140.   else if (m_bRecvStatus)
     9 ]5 d5 o8 P& H& c
141.   {
     
142.     m_cBuffer[buf_len] = ch;
     
143.     m_cBuffer[buf_len + 1] = '\0';
     
144.     //m_nIndex++;
     8 S  A8 }4 ~% j- W% K! _. Y
145.   }
     
146. }
     
147. //解析Hex文件
     & H5 [  W4 p4 n5 M5 N
148. void Hex::ParseHex(char *data)
     1 M- u# N/ L; r/ ]8 K  v2 n3 D
149. {
     ) _( e! I  N2 J
150.   for (int i = 0; i < strlen(data);++i)
     
151.   {
     
152.     ParseRecord(data[i]);
     ' C. L% a# a* ]" D+ l+ Y- Q: N
153.   }
     
154. }
     
155. int main(int argc, char *argv[])
     " E) @9 R9 g5 O" I! A2 ]* a
156. {
     
157.   freopen("in.txt", "r", stdin);
     
158.   freopen("out.txt", "w", stdout);
     
159. 
     # I; L& e7 J0 d/ r% H
160.   Hex hex(':');
     
161.   char ch;
     
162.   while (cin>>ch)
     
163.   {
     
164.     hex.ParseRecord(ch);
     
165.   }
     7 O$ ]7 w, ~" s+ b+ U
166.   fclose(stdout);
     & C7 M5 U* ^7 o; P4 L' o8 t
167.   fclose(stdin);
     5 o: o, |5 i& `2 g# u
168.   return 0;
     5 k5 w0 l/ ~7 J4 B2 i: S2 K
169. }

复制代码

  _' K$ T% ?, s5 C$ _' T4 Y2 o- e

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

+ J7 n/ n& P! ]8 q+ ]  F

mark~~~~~

不错