开源一个HEX转BIN代码

zouzhichao

代码自己写的，在Ubuntu下GCC编译通过，经少量AVR的HEX测试无误，如有纰漏错误，请自行判断纠正！！！！！！！！！！！！！！

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. typedef signed char int8_t;
   
6. typedef unsigned char uint8_t;
   
7. typedef signed short int16_t;
   
8. typedef unsigned short uint16_t;
   
9. typedef signed int int32_t;
   
10. typedef unsigned int uint32_t;
    
11. typedef float flt_t;
    
12. typedef double lflt_t;
    
13. 
    
14. #define _not_hex_(src) ((('0' > src) || ('9' < src)) && (('a' > src) || ('f' < src)) && (('A' > src) || ('F' < src)))
    
15. 
    
16. #define _hex_trans_eq_(src,dst) \
    
17. { \
    
18.         if (_not_hex_(src)) \
    
19.         { \
    
20.                 return HEX_ERR; \
    
21.         } \
    
22.         if (('0' <= (src)) && ('9' >= (src))) \
    
23.         { \
    
24.                 dst = (src) - '0'; \
    
25.         } \
    
26.         else if (('a' <= (src)) && ('f' >= (src))) \
    
27.         { \
    
28.                 dst = (src) - 'a' + 10; \
    
29.         } \
    
30.         else if (('A' <= (src)) && ('F' >= (src))) \
    
31.         { \
    
32.                 dst = (src) - 'A' + 10; \
    
33.         } \
    
34. }
    
35. 
    
36. #define _hex_trans_or_(src,dst) \
    
37. { \
    
38.         if (_not_hex_(src)) \
    
39.         { \
    
40.                 return HEX_ERR; \
    
41.         } \
    
42.         if (('0' <= (src)) && ('9' >= (src))) \
    
43.         { \
    
44.                 dst |= (src) - '0'; \
    
45.         } \
    
46.         else if (('a' <= (src)) && ('f' >= (src))) \
    
47.         { \
    
48.                 dst |= (src) - 'a' + 10; \
    
49.         } \
    
50.         else if (('A' <= (src)) && ('F' >= (src))) \
    
51.         { \
    
52.                 dst |= (src) - 'A' + 10; \
    
53.         } \
    
54. }
    
55. 
    
56. #define _hex_trans_or_shift_(src,dst) \
    
57. { \
    
58.         dst <<= 4; \
    
59.         _hex_trans_or_(src,dst); \
    
60. }
    
61. 
    
62. enum RESULT{HEX_ERR = -1, HEX_DATA_OK = 0, HEX_END_OK = 1, HEX_LBA_OK = 2, HEX_SEG_OK = 3};
    
63. 
    
64. int8_t _hex2bin_(const uint8_t* src, uint8_t* dst, uint8_t* data_type, uint8_t* data_len, uint16_t* data_addr)
    
65. {
    
66.         uint8_t check_sum, i;
    
67.         // 如果源code长度小于11，表明源code有误！
    
68.         if (11 > strlen((const char*)src))
    
69.         {
    
70.                 return HEX_ERR;
    
71.         }
    
72. 
    
73.         // 校验起始字节是否为':'，如果不为':'，表明源code有误！
    
74.         if (':' != *src++)
    
75.         {
    
76.                 return HEX_ERR;
    
77.         }
    
78. 
    
79.         // 得到数据长度的高4位
    
80.         _hex_trans_eq_(*src, *data_len);
    
81.         src++;
    
82.         // 得到数据长度的低4位
    
83.         _hex_trans_or_shift_(*src, *data_len);
    
84.         src++;
    
85.         // 校验和
    
86.         check_sum = *data_len;
    
87. 
    
88.         // 得到数据地址
    
89.         _hex_trans_eq_(*src, *data_addr);
    
90.         src++;
    
91.         _hex_trans_or_shift_(*src, *data_addr);
    
92.         src++;
    
93.         // 校验和
    
94.         check_sum += *data_addr;
    
95.         _hex_trans_or_shift_(*src, *data_addr);
    
96.         src++;
    
97.         _hex_trans_or_shift_(*src, *data_addr);
    
98.         src++;
    
99.         // 校验和
    
100.         check_sum += *data_addr;
     
101. 
     
102.         // 得到数据类型
     
103.         _hex_trans_eq_(*src, *data_type);
     
104.         src++;
     
105.         _hex_trans_or_shift_(*src, *data_type);
     
106.         src++;
     
107.         // 校验和
     
108.         check_sum += *data_type;
     
109. 
     
110.         switch (*data_type)
     
111.         {
     
112.         case 0: // 数据记录
     
113.                 for (i = *data_len; i; i--, dst++)
     
114.                 {
     
115.                         _hex_trans_eq_(*src, *dst);
     
116.                         src++;
     
117.                         _hex_trans_or_shift_(*src, *dst);
     
118.                         src++;
     
119.                         // 校验和
     
120.                         check_sum += *dst;
     
121.                 }
     
122.                 // 校验
     
123.                 _hex_trans_eq_(*src, i);
     
124.                 src++;
     
125.                 _hex_trans_or_shift_(*src, i);
     
126.                 check_sum += i;
     
127.                 return check_sum? HEX_ERR : HEX_DATA_OK;
     
128.         case 1: // 文件结束记录
     
129.                 if (*data_addr)
     
130.                 {
     
131.                         return HEX_ERR;
     
132.                 }
     
133.                 // 校验
     
134.                 _hex_trans_eq_(*src, i);
     
135.                 src++;
     
136.                 _hex_trans_or_shift_(*src, i);
     
137.                 check_sum += i;
     
138.                 return check_sum? HEX_ERR : HEX_END_OK;
     
139.         case 2: // 扩展段地址记录
     
140.                 if (*data_addr)
     
141.                 {
     
142.                         return HEX_ERR;
     
143.                 }
     
144.                 // 得到扩展段地址
     
145.                 _hex_trans_eq_(*src, *data_addr);
     
146.                 src++;
     
147.                 _hex_trans_or_shift_(*src, *data_addr);
     
148.                 src++;
     
149.                 // 校验和
     
150.                 check_sum += *data_addr;
     
151.                 _hex_trans_or_shift_(*src, *data_addr);
     
152.                 src++;
     
153.                 _hex_trans_or_shift_(*src, *data_addr);
     
154.                 src++;
     
155.                 // 校验和
     
156.                 check_sum += *data_addr;
     
157.                 return check_sum? HEX_ERR : HEX_SEG_OK;
     
158.         case 4: // 扩展线性地址记录
     
159.                 if (*data_addr)
     
160.                 {
     
161.                         return HEX_ERR;
     
162.                 }
     
163.                 // 得到扩展段地址
     
164.                 // 得到数据地址
     
165.                 _hex_trans_eq_(*src, *data_addr);
     
166.                 src++;
     
167.                 _hex_trans_or_shift_(*src, *data_addr);
     
168.                 src++;
     
169.                 // 校验和
     
170.                 check_sum += *data_addr;
     
171.                 _hex_trans_or_shift_(*src, *data_addr);
     
172.                 src++;
     
173.                 _hex_trans_or_shift_(*src, *data_addr);
     
174.                 src++;
     
175.                 // 校验和
     
176.                 check_sum += *data_addr;
     
177.                 return check_sum? HEX_ERR : HEX_LBA_OK;
     
178.         default:
     
179.                 return HEX_ERR;
     
180.         }
     
181.         return HEX_ERR;
     
182. }
     
183. 
     
184. int8_t hex2bin(const int8_t* src_file_path, const int8_t* dst_file_path)
     
185. {
     
186.         uint8_t buffer_hex[1024], buffer_bin[256];
     
187.         uint8_t data_type, len_bin;
     
188.         uint16_t addr_low;
     
189.         uint32_t addr_high = 0;
     
190.         FILE* src_file;
     
191.         FILE* dst_file;
     
192.         src_file = fopen((const char*)src_file_path, "r");
     
193.         if (!src_file)
     
194.         {
     
195.                 return -1;
     
196.         }
     
197.         dst_file = fopen((const char*)dst_file_path, "wb");
     
198.         if (!dst_file)
     
199.         {
     
200.                 fclose(src_file);
     
201.                 return -1;
     
202.         }
     
203.         for ( ; !feof(src_file); )
     
204.         {
     
205.                 if (NULL == fgets((char*)buffer_hex, 1024, src_file))
     
206.                 {
     
207.                         break;
     
208.                 }
     
209.                 if (HEX_ERR == _hex2bin_((const uint8_t*)buffer_hex, (uint8_t*)buffer_bin, &data_type, &len_bin, &addr_low))
     
210.                 {
     
211.                         break;
     
212.                 }
     
213.                 switch (data_type)
     
214.                 {
     
215.                 case 0: // 数据记录
     
216.                         if (ftell(dst_file) != addr_low + addr_high)
     
217.                         {
     
218.                                 fseek(dst_file, addr_low + addr_high, SEEK_SET);
     
219.                         }
     
220.                         if (1 != fwrite((const uint8_t*)buffer_bin, len_bin, 1, dst_file))
     
221.                         {
     
222.                                 fclose(src_file);
     
223.                                 fclose(dst_file);
     
224.                                 return -1;
     
225.                         }
     
226.                         break;
     
227.                 case 1: // 文件结束记录
     
228.                         fclose(src_file);
     
229.                         fclose(dst_file);
     
230.                         return 0;
     
231.                 case 2: // 扩展段地址记录
     
232.                         addr_high = ((uint32_t)addr_low) << 2;
     
233.                         break;
     
234.                 case 4: // 扩展线性地址记录
     
235.                         addr_high = ((uint32_t)addr_low) << 16;
     
236.                         break;
     
237.                 default:
     
238.                         fclose(src_file);
     
239.                         fclose(dst_file);
     
240.                         return -1;
     
241.                 }
     
242.         }
     
243.         fclose(src_file);
     
244.         fclose(dst_file);
     
245.         return 0;
     
246. }
     
247. 
     
248. int main(void)
     
249. {
     
250.         if (!hex2bin((const int8_t*)"avr-test.hex",(const int8_t*)"avr-test.bin"))
     
251.                 printf("ok!\n");
     
252.         return 0;
     
253. }

复制代码

一匹狼

原来大伙都还没睡啊~

zouzhichao

一匹狼 发表于 2014-1-1 01:46
原来大伙都还没睡啊~

刚写完，还没验证几下

sunshulin

不错，顶一下

Excellence

看看。
谢。

ciddy

这个是必须要啊

loveskangaroo

这个必须顶。

guitou

顶顶,学习

四轴飞行器

为何这么吊 这么叼

NJ8888

变通变法时用编程器软件读入HEX,另存BIN

wns245249509

可以把将待转换的文件通过main的参数传进来，这样会方便很多啊。。。。。

bygreencn

HEX的format你都兼容？好像只是。。。

zouzhichao

wns245249509 发表于 2014-1-17 16:33
可以把将待转换的文件通过main的参数传进来，这样会方便很多啊。。。。。

是的，但是文件名空格问题不好解决

zouzhichao

bygreencn 发表于 2014-1-17 16:34
HEX的format你都兼容？好像只是。。。

这个暂时没有验证，只验证了WINAVR生成的几个文件，其他的还没试
这个是照着网上HEX的文件描诉写的（参考百度百科），描述支持哪几种，这个就支持哪几种

propor123

不错，谢谢。