BQ27510 电量计的校准 的 C语言实现

点击打开链接

根据TI官方MSP430平台移植修改过来的，在Omap37xx(wince)平台测试，理论上和平台无关，伸手党，赶紧复制粘贴代码吧。如果这篇文章帮助了你，给了好评也无妨。

[cpp] view
plaincopyprint?

1. /*
2. ================================================================================
3. *             Texas Instruments OMAP(TM) Platform Software
4. * (c) Copyright Texas Instruments, Incorporated. All Rights Reserved.
5. *
6. * Use of this software is controlled by the terms and conditions found
7. * in the license agreement under which this software has been supplied.
8. *
9. ================================================================================
10. */
11. //
12. //  File:  bqtool.c
13. //
14. #include <windows.h>
15. #include <stdio.h>
16. #include <stdlib.h>
17. #include <string.h>
18. #include <i2cproxy.h>
19. #include "bq27500.h"
20. #define CMD_MAX_DATA_SIZE   512
21. #define MAX_LINE_LEN        ((CMD_MAX_DATA_SIZE + 4) * 3)
22. #define CMD_RETRY_DELAY     100 /* in ms */
23. #define RETRY_LIMIT     3
24. typedef enum {
25. CMD_INVALID = 0,
26. CMD_R,  /* Read */
27. CMD_W,  /* Write */
28. CMD_C,  /* Compare */
29. CMD_X,  /* Delay */
30. } cmd_type_t;
31. /*
32. * DO NOT change the order of fields - particularly reg
33. * should be immediately followed by data
34. */
35. typedef struct {
36. cmd_type_t cmd_type;
37. unsigned char addr;
38. unsigned char reg;
39. union {
40. unsigned char bytes[CMD_MAX_DATA_SIZE + 1];
41. UINT delay;
42. } data;
43. unsigned char data_len;
44. UINT32 line_num;
45. CHAR    *line;
46. }cmd_t;
47. static UINT32 line_num;
48. /* Parse S into tokens separated by characters in DELIM.
49. If S is NULL, the saved pointer in SAVE_PTR is used as
50. the next starting point.  For example:
51. char s[] = "-abc-=-def";
52. char *sp;
53. x = strtok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
54. x = strtok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
55. x = strtok_r(NULL, "=", &sp);   // x = NULL
56. // s = "abc/0-def/0"
57. */
58. static char *strtok_r(char *s, const char *delim, char **save_ptr) {
59. char *token;
60. if (s == NULL) s = *save_ptr;
61. /* Scan leading delimiters.  */
62. s += strspn(s, delim);
63. if (*s == '\0')
64. return NULL;
65. /* Find the end of the token.  */
66. token = s;
67. s = strpbrk(token, delim);
68. if (s == NULL)
69. /* This token finishes the string.  */
70. *save_ptr = strchr(token, '\0');
71. else {
72. /* Terminate the token and make *SAVE_PTR point past it.  */
73. *s = '\0';
74. *save_ptr = s + 1;
75. }
76. return token;
77. }
78. static char *strtok(char *s, const char *delim)
79. {
80. static char *last;
81. return strtok_r(s, delim, &last);
82. }
83. //写I2C，根据自己平台修改相关实现
84. static BOOL i2c_write(HANDLE hI2C, cmd_t *cmd)
85. {
86. int ret;
87. DWORD udwTemp;
88. if(hI2C)
89. {
90. udwTemp=cmd->addr >>1;
91. DeviceIoControl(hI2C, IOCTL_I2C_SET_SLAVE_ADDRESS, &udwTemp, sizeof(udwTemp), NULL, 0, NULL, NULL);
92. SetFilePointer(hI2C,LOWORD(cmd->reg),NULL,FILE_BEGIN);
93. if(!WriteFile(hI2C, cmd->data.bytes, cmd->data_len, &udwTemp, NULL))
94. {
95. RETAILMSG(1,(TEXT("ERROR: i2c_write: I2c WriteFile failed.\r\n")));
96. }
97. }
98. return TRUE;
99. }
100. //读I2C，根据自己平台修改相关实现
101. static BOOL i2c_Read(HANDLE hI2C, cmd_t *cmd)
102. {
103. int ret;
104. DWORD udwTemp;
105. if(hI2C)
106. {
107. udwTemp=cmd->addr >>1;
108. DeviceIoControl(hI2C, IOCTL_I2C_SET_SLAVE_ADDRESS, &udwTemp, sizeof(udwTemp), NULL, 0, NULL, NULL);
109. SetFilePointer(hI2C,LOWORD(cmd->reg),NULL,FILE_BEGIN);
110. if(!ReadFile(hI2C, cmd->data.bytes, cmd->data_len,&udwTemp, NULL))
111. {
112. RETAILMSG(1,(TEXT("ERROR: i2c_Read: I2c ReadFile failed.\r\n")));
113. return FALSE;
114. }else
115. {
116. cmd->data_len=udwTemp;
117. }
118. }
119. return TRUE;
120. }
121. static BOOL do_exec_cmd(HANDLE i2c_file, cmd_t *cmd)
122. {
123. unsigned char tmp_buf[CMD_MAX_DATA_SIZE];
124. int j=0;
125. switch (cmd->cmd_type) {
126. case CMD_R:
127. return i2c_Read(i2c_file, cmd);
128. case CMD_W:
129. return i2c_write(i2c_file, cmd);
130. case CMD_C:
131. memcpy(tmp_buf, cmd->data.bytes, cmd->data_len);
132. if (!i2c_Read(i2c_file, cmd))
133. return FALSE;
134. if (memcmp(tmp_buf, cmd->data.bytes, cmd->data_len)) {
135. RETAILMSG(1, (TEXT("Command C failed at line %d\r\n"),cmd->line_num));
136. return FALSE;
137. }
138. return TRUE;
139. case CMD_X:
140. Sleep(cmd->data.delay);
141. return TRUE;
142. default:
143. RETAILMSG(1, (TEXT("Unsupported command at line %d\r\n"),cmd->line_num));
144. return FALSE;
145. }
146. }
147. static BOOL execute_cmd(HANDLE i2c_file, cmd_t *cmd)
148. {
149. int i = 1,j=0;
150. BOOL ret;
151. RETAILMSG(0,(TEXT("cmd:cmd_type=%d;addr=%02x,reg=%02x,cmd->data_len=%d,"),cmd->cmd_type,cmd->addr,cmd->reg,cmd->data_len));
152. #if 0   //only for debug TODO:delete
153. RETAILMSG(1,(TEXT("line=%d:"),cmd->line_num));
154. for(j=0;j<cmd->data_len;j++)
155. {
156. RETAILMSG(1,(TEXT("%02x "),cmd->data.bytes[j]));
157. }
158. RETAILMSG(1,(TEXT("\r\n")));
159. #endif
160. ret = do_exec_cmd(i2c_file, cmd);
161. //if execute failed,retry three times
162. while (!ret && i < RETRY_LIMIT) {
163. Sleep(CMD_RETRY_DELAY);
164. ret = do_exec_cmd(i2c_file, cmd);
165. i++;
166. }
167. if (!ret) {
168. RETAILMSG(1, (TEXT("Command execution failed at line %d addr=0x%02x reg=0x%02x\r\n"),cmd->line_num, cmd->addr, cmd->reg));
169. }
170. return ret;
171. }
172. static BOOL get_delay(UINT *delay)
173. {
174. char *tok;
175. UINT temp;
176. tok = strtok(NULL, " ");
177. if (!tok)
178. return FALSE; /*end of line or file */
179. if (1 != sscanf(tok, "%u", &temp)) {
180. RETAILMSG(1, (TEXT("Syntax error while parsing delay at line %d\r\n"),line_num));
181. return FALSE; /* syntax error */
182. }
183. *delay = (UINT)temp;
184. return TRUE;
185. }
186. /*
187. * Returns:
188. *   0: success
189. *   1: EOF
190. *  -1: Parse error
191. */
192. static int get_byte(unsigned char *byte)
193. {
194. char *tok;
195. unsigned char temp;
196. tok = strtok(NULL, " ");
197. if (!tok)
198. return 1; /*end of line or file */
199. if ((strlen(tok) != 2) || (sscanf(tok, "%2x", &temp) != 1)) {
200. RETAILMSG(1, (TEXT("Syntax error at line %d\r\n"), line_num));
201. return -1; /* syntax error */
202. }
203. *byte = (unsigned char)temp;
204. return 0;   /* success */
205. }
206. static BOOL get_addr_n_reg(cmd_t *cmd)
207. {
208. if (get_byte(&cmd->addr))
209. return FALSE;
210. if (get_byte(&cmd->reg))
211. return FALSE;
212. return TRUE;
213. }
214. static BOOL get_data_bytes(cmd_t *cmd)
215. {
216. int ret, i = 0;
217. cmd->data_len = 0;
218. do {
219. ret = get_byte(&cmd->data.bytes[i++]);
220. } while ((ret == 0) && (i <= CMD_MAX_DATA_SIZE));
221. if (ret == 0) {
222. RETAILMSG(1, (TEXT("More than allowed number of data bytes at line %d, data_len %d, i %d\r\n"), cmd->line_num,cmd->data_len, i));
223. return FALSE;
224. }
225. cmd->data_len = i - 1;
226. return TRUE;
227. }
228. static BOOL get_line(FILE *bqfs_file, char **buffer)
229. {
230. int c;
231. int i = 0;
232. BOOL ret = TRUE;
233. char *buf;
234. buf = malloc(MAX_LINE_LEN);
235. line_num++;
236. while (1) {
237. c = fgetc(bqfs_file);
238. if (feof(bqfs_file)) {
239. break;
240. } else if (ferror(bqfs_file)) {
241. RETAILMSG(1, (TEXT("File read error\r\n")));
242. ret = FALSE;
243. break;
244. }
245. if (((c == '\r') || (c == '\n') || (c == '\t')
246. || (c == ' ')) && (i == 0)) {
247. /*
248. * Skip leading white space, if any, at the beginning
249. * of the line because this interferes with strtok
250. */
251. RETAILMSG(1, (TEXT("Leading whitespace at line %d\r\n"),line_num));
252. if (c == '\n')
253. line_num++;
254. continue;   /* blank line, let's continue */
255. } else if (c == '\n') {
256. /* We've reached end of line */
257. break;
258. }
259. buf[i++] = c;
260. if (i == MAX_LINE_LEN) {
261. /*
262. * Re-allocate in case the line is longer than
263. * expected
264. */
265. buf = realloc(buf, MAX_LINE_LEN * 2);
266. RETAILMSG(1, (TEXT("Line %d longer than expected,reallocating..\r\n"), line_num));
267. } else if (i == MAX_LINE_LEN * 2) {
268. /*
269. * The line is already twice the expected maximum length
270. * - maybe the bqfs/dffs needs to be fixed
271. */
272. RETAILMSG(1, (TEXT("Line %d too long, abort parsing..\r\n"),line_num));
273. ret = FALSE;
274. break;
275. }
276. }
277. *buffer = buf;
278. buf[i] = '\0';
279. if (i < 1)
280. ret = FALSE;
281. return ret;
282. }
283. static BOOL get_cmd(FILE *bqfs_file, cmd_t *cmd)
284. {
285. char *res;
286. char *tok;
287. char *buf = NULL;
288. BOOL ret;
289. while ((ret = get_line(bqfs_file, &buf))) {
290. if (buf[0] == ';') {
291. /*
292. * Comment line - ignore it and get the
293. * next line
294. */
295. RETAILMSG(0, (TEXT("Comment line,line_num=%d\r\n"),line_num));
296. free(buf);
297. } else {
298. break;
299. }
300. }
301. if (!ret)
302. goto error;
303. cmd->line_num = line_num;
304. tok = strtok(buf, ":");
305. if (!tok || (strlen(tok) != 1)) {
306. RETAILMSG(1, (TEXT("Error parsing command at line %d\r\n"),line_num));
307. goto error;
308. }
309. switch (tok[0]) {
310. case 'R':
311. case 'r':
312. cmd->cmd_type = CMD_R;
313. if (!get_addr_n_reg(cmd))
314. goto error;
315. break;
316. case 'W':
317. case 'w':
318. cmd->cmd_type = CMD_W;
319. if (!get_addr_n_reg(cmd))
320. goto error;
321. if (!get_data_bytes(cmd))
322. goto error;
323. break;
324. case 'C':
325. case 'c':
326. cmd->cmd_type = CMD_C;
327. if (!get_addr_n_reg(cmd))
328. goto error;
329. if (!get_data_bytes(cmd))
330. goto error;
331. break;
332. case 'X':
333. case 'x':
334. cmd->cmd_type = CMD_X;
335. cmd->data_len = 1;       //only one data
336. if (!get_delay(&cmd->data.delay))
337. goto error;
338. break;
339. default:
340. RETAILMSG(1, (TEXT("No command or unexpected command at line %d.\r\n"),line_num));
341. goto error;
342. }
343. if(buf)
344. {
345. free(buf);
346. }
347. return TRUE;
348. error:
349. RETAILMSG(1, (TEXT("get_line error,line_num=%d\r\n"),line_num));
350. cmd->cmd_type = CMD_INVALID;
351. free(buf);
352. return FALSE;
353. }
354. //Param:char *fname
355. //  File to flash BQ27510 generate by TI's engineer.
356. //  for example:bq27510G3.bqfs(with G2 update G3 firmware)
357. int bqfs_flash(char *fname)
358. {
359. FILE *bqfs_file = NULL;
360. cmd_t *cmd = NULL;
361. int ret = 0;
362. DWORD udwTemp;
363. HANDLE hI2C=NULL;
364. RETAILMSG(0,(TEXT("bqfs_flush beging...\r\n")));
365. bqfs_file = fopen(fname, "r");
366. if (!bqfs_file) {
367. RETAILMSG(1,(TEXT("bqfs_flush fopen failed.\r\n")));
368. ret = -1;
369. goto end;
370. }
371. hI2C=CreateFile(BATT_I2C_PORT, GENERIC_READ | GENERIC_WRITE, 0,NULL, OPEN_EXISTING, 0, NULL);
372. if(!hI2C)
373. {
374. RETAILMSG(1,(TEXT("bqfs_flash: I2c CreateFile failed.\r\n")));
375. ret = -1;
376. goto end;
377. }
378. //I2C相关配置寻址，根据自己平台修改相关实现
379. //set slave address
380. udwTemp=I2CSLAVEADDR;
381. DeviceIoControl(hI2C, IOCTL_I2C_SET_SLAVE_ADDRESS, &udwTemp, sizeof(udwTemp), NULL, 0, NULL, NULL);
382. //set i2c work mode
383. udwTemp=I2C_SUBADDRESS_MODE_8;
384. DeviceIoControl(hI2C, IOCTL_I2C_SET_SUBADDRESS_MODE, &udwTemp, sizeof(udwTemp), NULL, 0, NULL, NULL);
385. //set i2c transfer speed
386. udwTemp=SLOWSPEED_MODE;
387. DeviceIoControl(hI2C, IOCTL_I2C_SET_BAUD_INDEX, &udwTemp, sizeof(udwTemp), NULL, 0, NULL, NULL);
388. cmd = malloc(sizeof(cmd_t));
389. if(!cmd)
390. {
391. RETAILMSG(1, (TEXT("bqfs_flash malloc failed.\r\n")));
392. ret=-1;
393. goto end;
394. }
395. while (get_cmd(bqfs_file, cmd) && execute_cmd(hI2C, cmd));
396. if (feof(bqfs_file)) {
397. RETAILMSG(1, (TEXT("programmed successfully!\r\n")));
398. ret = 0;
399. } else {
400. RETAILMSG(1, (TEXT("programming failed!!\r\n")));
401. ret = -1;
402. }
403. end:
404. if (cmd)
405. free(cmd);
406. if(hI2C)
407. {
408. CloseHandle(hI2C);
409. hI2C=NULL;
410. }
411. if (bqfs_file)
412. fclose(bqfs_file);
413. return ret;
414. }