[长]CRC全套校验码生成函数源码(非查表)逐位运算法

e1ki0lp

新手,闲的没事写的,所有的crc校验基本就都是一个套路,我这里写了crc-4,5,6,7,8,16,32的校验码生成函数,
64的没怎么见过,没写,不过根据前面的套路,很容易就写出来了.

其实并不是所有的情况都需要讲究速度,比如DS18B20那种器件,就8个字节的寄存器,校验起来很容易的.不需要查表,逐位运算就能满足要求.
逐位运算好处是不用写表了,弱点也很明显,速度慢.

废话不多说,贴代码

1. 
   
2. uint8_t crc4_itu(uint8_t *data, uint_len length);
   
3. uint8_t crc5_epc(uint8_t *data, uint_len length);
   
4. uint8_t crc5_itu(uint8_t *data, uint_len length);
   
5. uint8_t crc5_usb(uint8_t *data, uint_len length);
   
6. uint8_t crc6_itu(uint8_t *data, uint_len length);
   
7. uint8_t crc7_mmc(uint8_t *data, uint_len length);
   
8. uint8_t crc8(uint8_t *data, uint_len length);
   
9. uint8_t crc8_itu(uint8_t *data, uint_len length);
   
10. uint8_t crc8_rohc(uint8_t *data, uint_len length);
    
11. uint8_t crc8_maxim(uint8_t *data, uint_len length);
    
12. uint16_t crc16_ibm(uint8_t *data, uint_len length);
    
13. uint16_t crc16_maxim(uint8_t *data, uint_len length);
    
14. uint16_t crc16_usb(uint8_t *data, uint_len length);
    
15. uint16_t crc16_modbus(uint8_t *data, uint_len length);
    
16. uint16_t crc16_ccitt(uint8_t *data, uint_len length);
    
17. uint16_t crc16_ccitt_false(uint8_t *data, uint_len length);
    
18. uint16_t crc16_x25(uint8_t *data, uint_len length);
    
19. uint16_t crc16_xmodem(uint8_t *data, uint_len length);
    
20. uint16_t crc16_dnp(uint8_t *data, uint_len length);
    
21. uint32_t crc32(uint8_t *data, uint_len length);
    
22. uint32_t crc32_mpeg_2(uint8_t *data, uint_len length);
    
23. /******************************************************************************
    
24. * Name:    CRC-4/ITU           x4+x+1
    
25. * Poly:    0x03
    
26. * Init:    0x00
    
27. * Refin:   True
    
28. * Refout:  True
    
29. * Xorout:  0x00
    
30. * Note:
    
31. *****************************************************************************/
    
32. uint8_t crc4_itu(uint8_t *data, uint_len length)
    
33. {
    
34.     uint8_t i;
    
35.     uint8_t crc = 0;                // Initial value
    
36.     while(length--)
    
37.     {
    
38.         crc ^= *data++;                 // crc ^= *data; data++;
    
39.         for (i = 0; i < 8; ++i)
    
40.         {
    
41.             if (crc & 1)
    
42.                 crc = (crc >> 1) ^ 0x0C;// 0x0C = (reverse 0x03)>>(8-4)
    
43.             else
    
44.                 crc = (crc >> 1);
    
45.         }
    
46.     }
    
47.     return crc;
    
48. }
    
49. 
    
50. /******************************************************************************
    
51. * Name:    CRC-5/EPC           x5+x3+1
    
52. * Poly:    0x09
    
53. * Init:    0x09
    
54. * Refin:   False
    
55. * Refout:  False
    
56. * Xorout:  0x00
    
57. * Note:
    
58. *****************************************************************************/
    
59. uint8_t crc5_epc(uint8_t *data, uint_len length)
    
60. {
    
61.     uint8_t i;
    
62.     uint8_t crc = 0x48;        // Initial value: 0x48 = 0x09<<(8-5)
    
63.     while(length--)
    
64.     {
    
65.         crc ^= *data++;        // crc ^= *data; data++;
    
66.         for ( i = 0; i < 8; i++ )
    
67.         {
    
68.             if ( crc & 0x80 )
    
69.                 crc = (crc << 1) ^ 0x48;        // 0x48 = 0x09<<(8-5)
    
70.             else
    
71.                 crc <<= 1;
    
72.         }
    
73.     }
    
74.     return crc >> 3;
    
75. }
    
76. 
    
77. /******************************************************************************
    
78. * Name:    CRC-5/ITU           x5+x4+x2+1
    
79. * Poly:    0x15
    
80. * Init:    0x00
    
81. * Refin:   True
    
82. * Refout:  True
    
83. * Xorout:  0x00
    
84. * Note:
    
85. *****************************************************************************/
    
86. uint8_t crc5_itu(uint8_t *data, uint_len length)
    
87. {
    
88.     uint8_t i;
    
89.     uint8_t crc = 0;                // Initial value
    
90.     while(length--)
    
91.     {
    
92.         crc ^= *data++;                 // crc ^= *data; data++;
    
93.         for (i = 0; i < 8; ++i)
    
94.         {
    
95.             if (crc & 1)
    
96.                 crc = (crc >> 1) ^ 0x15;// 0x15 = (reverse 0x15)>>(8-5)
    
97.             else
    
98.                 crc = (crc >> 1);
    
99.         }
    
100.     }
     
101.     return crc;
     
102. }
     
103. 
     
104. /******************************************************************************
     
105. * Name:    CRC-5/USB           x5+x2+1
     
106. * Poly:    0x05
     
107. * Init:    0x1F
     
108. * Refin:   True
     
109. * Refout:  True
     
110. * Xorout:  0x1F
     
111. * Note:
     
112. *****************************************************************************/
     
113. uint8_t crc5_usb(uint8_t *data, uint_len length)
     
114. {
     
115.     uint8_t i;
     
116.     uint8_t crc = 0x1F;                // Initial value
     
117.     while(length--)
     
118.     {
     
119.         crc ^= *data++;                 // crc ^= *data; data++;
     
120.         for (i = 0; i < 8; ++i)
     
121.         {
     
122.             if (crc & 1)
     
123.                 crc = (crc >> 1) ^ 0x14;// 0x14 = (reverse 0x05)>>(8-5)
     
124.             else
     
125.                 crc = (crc >> 1);
     
126.         }
     
127.     }
     
128.     return crc ^ 0x1F;
     
129. }
     
130. 
     
131. /******************************************************************************
     
132. * Name:    CRC-6/ITU           x6+x+1
     
133. * Poly:    0x03
     
134. * Init:    0x00
     
135. * Refin:   True
     
136. * Refout:  True
     
137. * Xorout:  0x00
     
138. * Note:
     
139. *****************************************************************************/
     
140. uint8_t crc6_itu(uint8_t *data, uint_len length)
     
141. {
     
142.     uint8_t i;
     
143.     uint8_t crc = 0;         // Initial value
     
144.     while(length--)
     
145.     {
     
146.         crc ^= *data++;        // crc ^= *data; data++;
     
147.         for (i = 0; i < 8; ++i)
     
148.         {
     
149.             if (crc & 1)
     
150.                 crc = (crc >> 1) ^ 0x30;// 0x30 = (reverse 0x03)>>(8-6)
     
151.             else
     
152.                 crc = (crc >> 1);
     
153.         }
     
154.     }
     
155.     return crc;
     
156. }
     
157. 
     
158. /******************************************************************************
     
159. * Name:    CRC-7/MMC           x7+x3+1
     
160. * Poly:    0x09
     
161. * Init:    0x00
     
162. * Refin:   False
     
163. * Refout:  False
     
164. * Xorout:  0x00
     
165. * Use:     MultiMediaCard,SD,ect.
     
166. *****************************************************************************/
     
167. uint8_t crc7_mmc(uint8_t *data, uint_len length)
     
168. {
     
169.     uint8_t i;
     
170.     uint8_t crc = 0;        // Initial value
     
171.     while(length--)
     
172.     {
     
173.         crc ^= *data++;        // crc ^= *data; data++;
     
174.         for ( i = 0; i < 8; i++ )
     
175.         {
     
176.             if ( crc & 0x80 )
     
177.                 crc = (crc << 1) ^ 0x12;        // 0x12 = 0x09<<(8-7)
     
178.             else
     
179.                 crc <<= 1;
     
180.         }
     
181.     }
     
182.     return crc >> 1;
     
183. }
     
184. 
     
185. /******************************************************************************
     
186. * Name:    CRC-8               x8+x2+x+1
     
187. * Poly:    0x07
     
188. * Init:    0x00
     
189. * Refin:   False
     
190. * Refout:  False
     
191. * Xorout:  0x00
     
192. * Note:
     
193. *****************************************************************************/
     
194. uint8_t crc8(uint8_t *data, uint_len length)
     
195. {
     
196.     uint8_t i;
     
197.     uint8_t crc = 0;        // Initial value
     
198.     while(length--)
     
199.     {
     
200.         crc ^= *data++;        // crc ^= *data; data++;
     
201.         for ( i = 0; i < 8; i++ )
     
202.         {
     
203.             if ( crc & 0x80 )
     
204.                 crc = (crc << 1) ^ 0x07;
     
205.             else
     
206.                 crc <<= 1;
     
207.         }
     
208.     }
     
209.     return crc;
     
210. }
     
211. 
     
212. /******************************************************************************
     
213. * Name:    CRC-8/ITU           x8+x2+x+1
     
214. * Poly:    0x07
     
215. * Init:    0x00
     
216. * Refin:   False
     
217. * Refout:  False
     
218. * Xorout:  0x55
     
219. * Alias:   CRC-8/ATM
     
220. *****************************************************************************/
     
221. uint8_t crc8_itu(uint8_t *data, uint_len length)
     
222. {
     
223.     uint8_t i;
     
224.     uint8_t crc = 0;        // Initial value
     
225.     while(length--)
     
226.     {
     
227.         crc ^= *data++;        // crc ^= *data; data++;
     
228.         for ( i = 0; i < 8; i++ )
     
229.         {
     
230.             if ( crc & 0x80 )
     
231.                 crc = (crc << 1) ^ 0x07;
     
232.             else
     
233.                 crc <<= 1;
     
234.         }
     
235.     }
     
236.     return crc ^ 0x55;
     
237. }
     
238. 
     
239. /******************************************************************************
     
240. * Name:    CRC-8/ROHC          x8+x2+x+1
     
241. * Poly:    0x07
     
242. * Init:    0xFF
     
243. * Refin:   True
     
244. * Refout:  True
     
245. * Xorout:  0x00
     
246. * Note:
     
247. *****************************************************************************/
     
248. uint8_t crc8_rohc(uint8_t *data, uint_len length)
     
249. {
     
250.     uint8_t i;
     
251.     uint8_t crc = 0xFF;         // Initial value
     
252.     while(length--)
     
253.     {
     
254.         crc ^= *data++;            // crc ^= *data; data++;
     
255.         for (i = 0; i < 8; ++i)
     
256.         {
     
257.             if (crc & 1)
     
258.                 crc = (crc >> 1) ^ 0xE0;        // 0xE0 = reverse 0x07
     
259.             else
     
260.                 crc = (crc >> 1);
     
261.         }
     
262.     }
     
263.     return crc;
     
264. }
     
265. 
     
266. /******************************************************************************
     
267. * Name:    CRC-8/MAXIM         x8+x5+x4+1
     
268. * Poly:    0x31
     
269. * Init:    0x00
     
270. * Refin:   True
     
271. * Refout:  True
     
272. * Xorout:  0x00
     
273. * Alias:   DOW-CRC,CRC-8/IBUTTON
     
274. * Use:     Maxim(Dallas)'s some devices,e.g. DS18B20
     
275. *****************************************************************************/
     
276. uint8_t crc8_maxim(uint8_t *data, uint_len length)
     
277. {
     
278.     uint8_t i;
     
279.     uint8_t crc = 0;         // Initial value
     
280.     while(length--)
     
281.     {
     
282.         crc ^= *data++;        // crc ^= *data; data++;
     
283.         for (i = 0; i < 8; i++)
     
284.         {
     
285.             if (crc & 1)
     
286.                 crc = (crc >> 1) ^ 0x8C;        // 0x8C = reverse 0x31
     
287.             else
     
288.                 crc >>= 1;
     
289.         }
     
290.     }
     
291.     return crc;
     
292. }
     
293. 
     
294. /******************************************************************************
     
295. * Name:    CRC-16/IBM          x16+x15+x2+1
     
296. * Poly:    0x8005
     
297. * Init:    0x0000
     
298. * Refin:   True
     
299. * Refout:  True
     
300. * Xorout:  0x0000
     
301. * Alias:   CRC-16,CRC-16/ARC,CRC-16/LHA
     
302. *****************************************************************************/
     
303. uint16_t crc16_ibm(uint8_t *data, uint_len length)
     
304. {
     
305.     uint8_t i;
     
306.     uint16_t crc = 0;        // Initial value
     
307.     while(length--)
     
308.     {
     
309.         crc ^= *data++;        // crc ^= *data; data++;
     
310.         for (i = 0; i < 8; ++i)
     
311.         {
     
312.             if (crc & 1)
     
313.                 crc = (crc >> 1) ^ 0xA001;        // 0xA001 = reverse 0x8005
     
314.             else
     
315.                 crc = (crc >> 1);
     
316.         }
     
317.     }
     
318.     return crc;
     
319. }
     
320. 
     
321. /******************************************************************************
     
322. * Name:    CRC-16/MAXIM        x16+x15+x2+1
     
323. * Poly:    0x8005
     
324. * Init:    0x0000
     
325. * Refin:   True
     
326. * Refout:  True
     
327. * Xorout:  0xFFFF
     
328. * Note:
     
329. *****************************************************************************/
     
330. uint16_t crc16_maxim(uint8_t *data, uint_len length)
     
331. {
     
332.     uint8_t i;
     
333.     uint16_t crc = 0;        // Initial value
     
334.     while(length--)
     
335.     {
     
336.         crc ^= *data++;        // crc ^= *data; data++;
     
337.         for (i = 0; i < 8; ++i)
     
338.         {
     
339.             if (crc & 1)
     
340.                 crc = (crc >> 1) ^ 0xA001;        // 0xA001 = reverse 0x8005
     
341.             else
     
342.                 crc = (crc >> 1);
     
343.         }
     
344.     }
     
345.     return ~crc;    // crc^0xffff
     
346. }
     
347. 
     
348. /******************************************************************************
     
349. * Name:    CRC-16/USB          x16+x15+x2+1
     
350. * Poly:    0x8005
     
351. * Init:    0xFFFF
     
352. * Refin:   True
     
353. * Refout:  True
     
354. * Xorout:  0xFFFF
     
355. * Note:
     
356. *****************************************************************************/
     
357. uint16_t crc16_usb(uint8_t *data, uint_len length)
     
358. {
     
359.     uint8_t i;
     
360.     uint16_t crc = 0xffff;        // Initial value
     
361.     while(length--)
     
362.     {
     
363.         crc ^= *data++;            // crc ^= *data; data++;
     
364.         for (i = 0; i < 8; ++i)
     
365.         {
     
366.             if (crc & 1)
     
367.                 crc = (crc >> 1) ^ 0xA001;        // 0xA001 = reverse 0x8005
     
368.             else
     
369.                 crc = (crc >> 1);
     
370.         }
     
371.     }
     
372.     return ~crc;    // crc^0xffff
     
373. }
     
374. 
     
375. /******************************************************************************
     
376. * Name:    CRC-16/MODBUS       x16+x15+x2+1
     
377. * Poly:    0x8005
     
378. * Init:    0xFFFF
     
379. * Refin:   True
     
380. * Refout:  True
     
381. * Xorout:  0x0000
     
382. * Note:
     
383. *****************************************************************************/
     
384. uint16_t crc16_modbus(uint8_t *data, uint_len length)
     
385. {
     
386.     uint8_t i;
     
387.     uint16_t crc = 0xffff;        // Initial value
     
388.     while(length--)
     
389.     {
     
390.         crc ^= *data++;            // crc ^= *data; data++;
     
391.         for (i = 0; i < 8; ++i)
     
392.         {
     
393.             if (crc & 1)
     
394.                 crc = (crc >> 1) ^ 0xA001;        // 0xA001 = reverse 0x8005
     
395.             else
     
396.                 crc = (crc >> 1);
     
397.         }
     
398.     }
     
399.     return crc;
     
400. }
     
401. 
     
402. /******************************************************************************
     
403. * Name:    CRC-16/CCITT        x16+x12+x5+1
     
404. * Poly:    0x1021
     
405. * Init:    0x0000
     
406. * Refin:   True
     
407. * Refout:  True
     
408. * Xorout:  0x0000
     
409. * Alias:   CRC-CCITT,CRC-16/CCITT-TRUE,CRC-16/KERMIT
     
410. *****************************************************************************/
     
411. uint16_t crc16_ccitt(uint8_t *data, uint_len length)
     
412. {
     
413.     uint8_t i;
     
414.     uint16_t crc = 0;        // Initial value
     
415.     while(length--)
     
416.     {
     
417.         crc ^= *data++;        // crc ^= *data; data++;
     
418.         for (i = 0; i < 8; ++i)
     
419.         {
     
420.             if (crc & 1)
     
421.                 crc = (crc >> 1) ^ 0x8408;        // 0x8408 = reverse 0x1021
     
422.             else
     
423.                 crc = (crc >> 1);
     
424.         }
     
425.     }
     
426.     return crc;
     
427. }
     
428. 
     
429. /******************************************************************************
     
430. * Name:    CRC-16/CCITT-FALSE   x16+x12+x5+1
     
431. * Poly:    0x1021
     
432. * Init:    0xFFFF
     
433. * Refin:   False
     
434. * Refout:  False
     
435. * Xorout:  0x0000
     
436. * Note:
     
437. *****************************************************************************/
     
438. uint16_t crc16_ccitt_false(uint8_t *data, uint_len length)
     
439. {
     
440.     uint8_t i;
     
441.     uint16_t crc = 0xffff;        //Initial value
     
442.     while(length--)
     
443.     {
     
444.         crc ^= (uint16_t)(*data++) << 8; // crc ^= (uint6_t)(*data)<<8; data++;
     
445.         for (i = 0; i < 8; ++i)
     
446.         {
     
447.             if ( crc & 0x8000 )
     
448.                 crc = (crc << 1) ^ 0x1021;
     
449.             else
     
450.                 crc <<= 1;
     
451.         }
     
452.     }
     
453.     return crc;
     
454. }
     
455. 
     
456. /******************************************************************************
     
457. * Name:    CRC-16/X25          x16+x12+x5+1
     
458. * Poly:    0x1021
     
459. * Init:    0xFFFF
     
460. * Refin:   True
     
461. * Refout:  True
     
462. * Xorout:  0XFFFF
     
463. * Note:
     
464. *****************************************************************************/
     
465. uint16_t crc16_x25(uint8_t *data, uint_len length)
     
466. {
     
467.     uint8_t i;
     
468.     uint16_t crc = 0xffff;        // Initial value
     
469.     while(length--)
     
470.     {
     
471.         crc ^= *data++;            // crc ^= *data; data++;
     
472.         for (i = 0; i < 8; ++i)
     
473.         {
     
474.             if (crc & 1)
     
475.                 crc = (crc >> 1) ^ 0x8408;        // 0x8408 = reverse 0x1021
     
476.             else
     
477.                 crc = (crc >> 1);
     
478.         }
     
479.     }
     
480.     return ~crc;                // crc^Xorout
     
481. }
     
482. 
     
483. /******************************************************************************
     
484. * Name:    CRC-16/XMODEM       x16+x12+x5+1
     
485. * Poly:    0x1021
     
486. * Init:    0x0000
     
487. * Refin:   False
     
488. * Refout:  False
     
489. * Xorout:  0x0000
     
490. * Alias:   CRC-16/ZMODEM,CRC-16/ACORN
     
491. *****************************************************************************/
     
492. uint16_t crc16_xmodem(uint8_t *data, uint_len length)
     
493. {
     
494.     uint8_t i;
     
495.     uint16_t crc = 0;            // Initial value
     
496.     while(length--)
     
497.     {
     
498.         crc ^= (uint16_t)(*data++) << 8; // crc ^= (uint16_t)(*data)<<8; data++;
     
499.         for (i = 0; i < 8; ++i)
     
500.         {
     
501.             if ( crc & 0x8000 )
     
502.                 crc = (crc << 1) ^ 0x1021;
     
503.             else
     
504.                 crc <<= 1;
     
505.         }
     
506.     }
     
507.     return crc;
     
508. }
     
509. 
     
510. /******************************************************************************
     
511. * Name:    CRC-16/DNP          x16+x13+x12+x11+x10+x8+x6+x5+x2+1
     
512. * Poly:    0x3D65
     
513. * Init:    0x0000
     
514. * Refin:   True
     
515. * Refout:  True
     
516. * Xorout:  0xFFFF
     
517. * Use:     M-Bus,ect.
     
518. *****************************************************************************/
     
519. uint16_t crc16_dnp(uint8_t *data, uint_len length)
     
520. {
     
521.     uint8_t i;
     
522.     uint16_t crc = 0;            // Initial value
     
523.     while(length--)
     
524.     {
     
525.         crc ^= *data++;            // crc ^= *data; data++;
     
526.         for (i = 0; i < 8; ++i)
     
527.         {
     
528.             if (crc & 1)
     
529.                 crc = (crc >> 1) ^ 0xA6BC;        // 0xA6BC = reverse 0x3D65
     
530.             else
     
531.                 crc = (crc >> 1);
     
532.         }
     
533.     }
     
534.     return ~crc;                // crc^Xorout
     
535. }
     
536. 
     
537. /******************************************************************************
     
538. * Name:    CRC-32  x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
     
539. * Poly:    0x4C11DB7
     
540. * Init:    0xFFFFFFF
     
541. * Refin:   True
     
542. * Refout:  True
     
543. * Xorout:  0xFFFFFFF
     
544. * Alias:   CRC_32/ADCCP
     
545. * Use:     WinRAR,ect.
     
546. *****************************************************************************/
     
547. uint32_t crc32(uint8_t *data, uint_len length)
     
548. {
     
549.     uint8_t i;
     
550.     uint32_t crc = 0xffffffff;        // Initial value
     
551.     while(length--)
     
552.     {
     
553.         crc ^= *data++;                // crc ^= *data; data++;
     
554.         for (i = 0; i < 8; ++i)
     
555.         {
     
556.             if (crc & 1)
     
557.                 crc = (crc >> 1) ^ 0xEDB88320;// 0xEDB88320= reverse 0x04C11DB7
     
558.             else
     
559.                 crc = (crc >> 1);
     
560.         }
     
561.     }
     
562.     return ~crc;
     
563. }
     
564. 
     
565. /******************************************************************************
     
566. * Name:    CRC-32/MPEG-2  x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
     
567. * Poly:    0x4C11DB7
     
568. * Init:    0xFFFFFFF
     
569. * Refin:   False
     
570. * Refout:  False
     
571. * Xorout:  0x0000000
     
572. * Note:
     
573. *****************************************************************************/
     
574. uint32_t crc32_mpeg_2(uint8_t *data, uint_len length)
     
575. {
     
576.     uint8_t i;
     
577.     uint32_t crc = 0xffffffff;  // Initial value
     
578.     while(length--)
     
579.     {
     
580.         crc ^= (uint32_t)(*data++) << 24;// crc ^=(uint32_t)(*data)<<24; data++;
     
581.         for (i = 0; i < 8; ++i)
     
582.         {
     
583.             if ( crc & 0x80000000 )
     
584.                 crc = (crc << 1) ^ 0x04C11DB7;
     
585.             else
     
586.                 crc <<= 1;
     
587.         }
     
588.     }
     
589.     return crc;
     
590. }
     

复制代码

使用方法,首先根据数据长度,定义uint_len的类型
比如        typedef uint16_t uint_len;
然后定义一组测试数据
比如         uint8_t serno[] = { 0x91, 0xA3, 0xB5, 0xC7, 0x8D, 0xEB, 0x2D, 0X4E,};
最后输出对应的校验码
    printf("0x%X\n", crc8(serno, sizeof(serno))); //CRC-8
    printf("0x%X\n", crc32(serno, sizeof(serno))); //CRC-32

我是按照网上的crc小工具来的,图片里的所有校验函数都写了


参考资料是AVR-GCC的库util/crc16.h
http://www.nongnu.org/avr-libc/user-manual/group__util__crc.html

wlksosfytz

这CRC不错，楼猪辛苦了！！！

mohao123

非常棒，刚好在找着方面的东西

bailao99

谢谢楼主共享！

lzchuo

多谢分享，不错的资料

Excellence

先标记，不错资料，谢谢楼主。

AllEle

不错，mk了

lzly0302

这个不错，先收藏了

KING_632

CRC校验，MARK

hanhuliang

多谢楼主，留贴备用。

HZKJ

很规范的源代码，不错。不过现在STM32自带的CRC硬件更好用。

jxcrg_t35

谢谢分享。

e1ki0lp

HZKJ 发表于 2015-12-8 19:40
很规范的源代码，不错。不过现在STM32自带的CRC硬件更好用。

主要是针对某些低端芯片,比如avr这种.

t3486784401

还针对某些有 BT 要求的 CRC 应用场合，例如指定用非标准多项式（POLY）

whhb8612

多谢楼主，备用

delazio

如果你会python，有个库叫pycrc，可以生成随便一个计算模式和多项式的代码...

dengterry

占楼 备用

e1ki0lp

delazio 发表于 2015-12-13 22:39
如果你会python，有个库叫pycrc，可以生成随便一个计算模式和多项式的代码... ...

恩,刚查了一下,看样子不错,这几天学学python.

dr2001

e1ki0lp 发表于 2015-12-14 01:16
恩,刚查了一下,看样子不错,这几天学学python.

通用生成器基本没必要。
CRC重要的是你的源代码注释中的那些方向，多项式等信息。

自己做好几个查表法的函数就够了，剩下的就是用预处理器或者函数生成必要的表。。。

资源受限环境半字节查表吧。

dory_m

学习，谢谢！！！

e1ki0lp

dr2001 发表于 2015-12-14 08:14
通用生成器基本没必要。
CRC重要的是你的源代码注释中的那些方向，多项式等信息。

短数据,非高速通讯的情况下,逐位运算就够了.表都省了.就一个函数搞定

楼上朋友说的那个pytnon库,我仔细看了一下,确实很好,除了能生成查表法,逐位运算法的C代码好像也可以生成.
多项式,方向,异或输入输出等信息都可以自定义

我确实是重复造轮子了.

钛50

留着，备用。谢谢

nil00

谢谢分享！

sam.jheng

感謝!超級實用。

micyoco

感谢楼主，用在单片机中非常好

dun2010

谢谢分享！

黄叶飞

Mark一下

工科男生

谢谢，很好用！

yangzi8000

wo  mark...............

zlutian

谢谢，备用