c# CRC校验
用于学习记录
原文载自：https://www.cnblogs.com/ayxj/p/11481969.html
用C#实现的几种常用数据校验方法整理（CRC校验；LRC校验；BCC校验；累加和校验）
CRC即循环冗余校验码（Cyclic Redundancy Check）：是数据通信领域中最常用的一种查错校验码，其特征是信息字段和校验字段的长度可以任意选定。循环冗余检查（CRC）是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性和完整性。
/// CRC算法参数模型解释：
/// NAME：参数模型名称。
///WIDTH：宽度，即CRC比特数。
/// POLY：生成项的简写，以16进制表示。例如：CRC-32即是0x04C11DB7，忽略了最高位的"1"，即完整的生成项是0x104C11DB7。
///INIT：这是算法开始时寄存器（crc）的初始化预置值，十六进制表示。
///REFIN：待测数据的每个字节是否按位反转，True或False。
/// REFOUT：在计算后之后，异或输出之前，整个数据是否按位反转，True或False。
/// XOROUT：计算结果与此参数异或后得到最终的CRC值。
1 /// **********************************************************************
2 /// Name: CRC-4/ITU x4+x+1
3 /// Poly: 0x03
4 /// Init: 0x00
5 /// Refin: true
6 /// Refout: true
7 /// Xorout: 0x00
8 ///*************************************************************************
9 public static byte[] Crc1(byte[] buffer, int start = 0, int len = 0)
10 {
11 if (buffer == null || buffer.Length == 0) return null;
12 if (start < 0) return null;
13 if (len == 0) len = buffer.Length - start;
14 int length = start + len;
15 if (length > buffer.Length) return null;
16 byte crc = 0;// Initial value
17 for (int i = start; i < length; i++)
18 {
19 crc ^= buffer[i];
20 for (int j = 0; j < 8; j++)
21 {
22 if ((crc & 1) > 0)
23 crc = (byte)((crc >> 1) ^ 0x0C);//0x0C = (reverse 0x03)>>(8-4)
24 else
25 crc = (byte)(crc >> 1);
26 }
27 }
28 return new byte[] { crc };
29 }
30 /// **********************************************************************
31 /// Name: CRC-5/EPC x5+x3+1
32 /// Poly: 0x09
33 /// Init: 0x09
34 /// Refin: false
35 /// Refout: false
36 /// Xorout: 0x00
37 ///*************************************************************************
38 public static byte[] Crc2(byte[] buffer, int start = 0, int len = 0)
39 {
40 if (buffer == null || buffer.Length == 0) return null;
41 if (start < 0) return null;
42 if (len == 0) len = buffer.Length - start;
43 int length = start + len;
44 if (length > buffer.Length) return null;
45 byte crc = 0x48;// Initial value: 0x48 = 0x09<<(8-5)
46 for (int i = start; i < length; i++)
47 {
48 crc ^= buffer[i];
49 for (int j = 0; j < 8; j++)
50 {
51 if ((crc & 0x80) > 0)
52 crc = (byte)((crc << 1) ^ 0x48);// 0x48 = 0x09<<(8-5)
53 else
54 crc = (byte)(crc << 1);
55 }
56 }
57 return new byte[] { (byte)(crc >> 3) };
58 }
59 /// **********************************************************************
60 /// Name: CRC-5/ITU x5+x4+x2+1
61 /// Poly: 0x15
62 /// Init: 0x00
63 /// Refin: true
64 /// Refout: true
65 /// Xorout: 0x00
66 ///*************************************************************************
67 public static byte[] Crc3(byte[] buffer, int start = 0, int len = 0)
68 {
69 if (buffer == null || buffer.Length == 0) return null;
70 if (start < 0) return null;
71 if (len == 0) len = buffer.Length - start;
72 int length = start + len;
73 if (length > buffer.Length) return null;
74 byte crc = 0;// Initial value
75 for (int i = start; i < length; i++)
76 {
77 crc ^= buffer[i];
78 for (int j = 0; j < 8; j++)
79 {
80 if ((crc & 1) > 0)
81 crc = (byte)((crc >> 1) ^ 0x15);// 0x15 = (reverse 0x15)>>(8-5)
82 else
83 crc = (byte)(crc >> 1);
84 }
85 }
86 return new byte[] { crc };
87 }
88 /// **********************************************************************
89 /// Name: CRC-5/USB x5+x2+1
90 /// Poly: 0x05
91 /// Init: 0x1F
92 /// Refin: true
93 /// Refout: true
94 /// Xorout: 0x1F
95 ///*************************************************************************
96 public static byte[] Crc4(byte[] buffer, int start = 0, int len = 0)
97 {
98 if (buffer == null || buffer.Length == 0) return null;
99 if (start < 0) return null;
100 if (len == 0) len = buffer.Length - start;
101 int length = start + len;
102 if (length > buffer.Length) return null;
103 byte crc = 0x1F;// Initial value
104 for (int i = start; i < length; i++)
105 {
106 crc ^= buffer[i];
107 for (int j = 0; j < 8; j++)
108 {
109 if ((crc & 1) > 0)
110 crc = (byte)((crc >> 1) ^ 0x14);// 0x14 = (reverse 0x05)>>(8-5)
111 else
112 crc = (byte)(crc >> 1);
113 }
114 }
115 return new byte[] {(byte)( crc ^ 0x1F) };
116 }
117 /// **********************************************************************
118 /// Name: CRC-6/ITU x6+x+1
119 /// Poly: 0x03
120 /// Init: 0x00
121 /// Refin: true
122 /// Refout: true
123 /// Xorout: 0x00
124 ///*************************************************************************
125 public static byte[] Crc5(byte[] buffer, int start = 0, int len = 0)
126 {
127 if (buffer == null || buffer.Length == 0) return null;
128 if (start < 0) return null;
129 if (len == 0) len = buffer.Length - start;
130 int length = start + len;
131 if (length > buffer.Length) return null;
132 byte crc = 0;// Initial value
133 for (int i = start; i < length; i++)
134 {
135 crc ^= buffer[i];
136 for (int j = 0; j < 8; j++)
137 {
138 if ((crc & 1) > 0)
139 crc = (byte)((crc >> 1) ^ 0x30);// 0x30 = (reverse 0x03)>>(8-6)
140 else
141 crc = (byte)(crc >> 1);
142 }
143 }
144 return new byte[] { crc };
145 }
146 /// **********************************************************************
147 /// Name: CRC-7/MMC x7+x3+1
148 /// Poly: 0x09
149 /// Init: 0x00
150 /// Refin: false
151 /// Refout: false
152 /// Xorout: 0x00
153 ///*************************************************************************
154 public static byte[] Crc6(byte[] buffer, int start = 0, int len = 0)
155 {
156 if (buffer == null || buffer.Length == 0) return null;
157 if (start < 0) return null;
158 if (len == 0) len = buffer.Length - start;
159 int length = start + len;
160 if (length > buffer.Length) return null;
161 byte crc = 0;// Initial value
162 for (int i = start; i < length; i++)
163 {
164 crc ^= buffer[i];
165 for (int j = 0; j < 8; j++)
166 {
167 if ((crc & 0x80) > 0)
168 crc = (byte)((crc << 1) ^ 0x12);// 0x12 = 0x09<<(8-7)
169 else
170 crc = (byte)(crc << 1);
171 }
172 }
173 return new byte[] { (byte)(crc >> 1) };
174 }
175 /// **********************************************************************
176 /// Name: CRC8 x8+x2+x+1
177 /// Poly: 0x07
178 /// Init: 0x00
179 /// Refin: false
180 /// Refout: false
181 /// Xorout: 0x00
182 ///*************************************************************************
183 public static byte[] Crc7(byte[] buffer, int start = 0, int len = 0)
184 {
185 if (buffer == null || buffer.Length == 0) return null;
186 if (start < 0) return null;
187 if (len == 0) len = buffer.Length - start;
188 int length = start + len;
189 if (length > buffer.Length) return null;
190 byte crc = 0;// Initial value
191 for (int i = start; i < length; i++)
192 {
193 crc ^= buffer[i];
194 for (int j = 0; j < 8; j++)
195 {
196 if ((crc & 0x80) > 0)
197 crc = (byte)((crc << 1) ^ 0x07);
198 else
199 crc = (byte)(crc << 1);
200 }
201 }
202 return new byte[] { crc };
203 }
204 /// **********************************************************************
205 /// Name: CRC-8/ITU x8+x2+x+1
206 /// Poly: 0x07
207 /// Init: 0x00
208 /// Refin: false
209 /// Refout: false
210 /// Xorout: 0x55
211 ///*************************************************************************
212 public static byte[] Crc8(byte[] buffer, int start = 0, int len = 0)
213 {
214 if (buffer == null || buffer.Length == 0) return null;
215 if (start < 0) return null;
216 if (len == 0) len = buffer.Length - start;
217 int length = start + len;
218 if (length > buffer.Length) return null;
219 byte crc = 0;// Initial value
220 for (int i = start; i < length; i++)
221 {
222 crc ^= buffer[i];
223 for (int j = 0; j < 8; j++)
224 {
225 if ((crc & 0x80) > 0)
226 crc = (byte)((crc << 1) ^ 0x07);
227 else
228 crc = (byte)(crc << 1);
229 }
230 }
231 return new byte[] { (byte)(crc ^ 0x55) };
232 }
233 /// **********************************************************************
234 /// Name: CRC-8/MAXIM x8+x5+x4+1
235 /// Poly: 0x31
236 /// Init: 0x00
237 /// Refin: true
238 /// Refout: true
239 /// Xorout: 0x00
240 ///*************************************************************************
241 public static byte[] Crc9(byte[] buffer, int start = 0, int len = 0)
242 {
243 if (buffer == null || buffer.Length == 0) return null;
244 if (start < 0) return null;
245 if (len == 0) len = buffer.Length - start;
246 int length = start + len;
247 if (length > buffer.Length) return null;
248 byte crc = 0;// Initial value
249 for (int i = start; i < length; i++)
250 {
251 crc ^= buffer[i];
252 for (int j = 0; j < 8; j++)
253 {
254 if ((crc & 1) > 0)
255 crc = (byte)((crc >> 1) ^ 0x8C);// 0x8C = reverse 0x31
256 else
257 crc = (byte)(crc >> 1);
258 }
259 }
260 return new byte[] { crc };
261 }
262 /// **********************************************************************
263 /// Name: CRC-8/ROHC x8+x2+x+1
264 /// Poly: 0x07
265 /// Init: 0xFF
266 /// Refin: true
267 /// Refout: true
268 /// Xorout: 0x00
269 ///*************************************************************************
270 public static byte[] Crc10(byte[] buffer, int start = 0, int len = 0)
271 {
272 if (buffer == null || buffer.Length == 0) return null;
273 if (start < 0) return null;
274 if (len == 0) len = buffer.Length - start;
275 int length = start + len;
276 if (length > buffer.Length) return null;
277 byte crc = 0xFF;// Initial value
278 for (int i = start; i < length; i++)
279 {
280 crc ^= buffer[i];
281 for (int j = 0; j < 8; j++)
282 {
283 if ((crc & 1) > 0)
284 crc = (byte)((crc >> 1) ^ 0xE0);// 0xE0 = reverse 0x07
285 else
286 crc = (byte)(crc >> 1);
287 }
288 }
289 return new byte[] { crc };
290 }
291 /// Z1协议校验码计算
292 static byte[] table = { 0x00, 0x1C, 0x38, 0x24, 0x70, 0x6C, 0x48, 0x54, 0xE0, 0xFC,
293 0xD8, 0xC4, 0x90, 0x8C, 0xA8, 0xB4, 0xDC, 0xC0, 0xE4, 0xF8,
294 0xAC, 0xB0, 0x94, 0x88, 0x3C, 0x20, 0x04, 0x18, 0x4C, 0x50,
295 0x74, 0x68, 0xA4, 0xB8, 0x9C, 0x80, 0xD4, 0xC8, 0xEC, 0xF0,
296 0x44, 0x58, 0x7C, 0x60, 0x34, 0x28, 0x0C, 0x10, 0x78, 0x64,
297 0x40, 0x5C, 0x08, 0x14, 0x30, 0x2C, 0x98, 0x84, 0xA0, 0xBC,
298 0xE8, 0xF4, 0xD0, 0xCC, 0x54, 0x48, 0x6C, 0x70, 0x24, 0x38,
299 0x1C, 0x00, 0xB4, 0xA8, 0x8C, 0x90, 0xC4, 0xD8, 0xFC, 0xE0,
300 0x88, 0x94, 0xB0, 0xAC, 0xF8, 0xE4, 0xC0, 0xDC, 0x68, 0x74,
301 0x50, 0x4C, 0x18, 0x04, 0x20, 0x3C, 0xF0, 0xEC, 0xC8, 0xD4,
302 0x80, 0x9C, 0xB8, 0xA4, 0x10, 0x0C, 0x28, 0x34, 0x60, 0x7C,
303 0x58, 0x44, 0x2C, 0x30, 0x14, 0x08, 0x5C, 0x40, 0x64, 0x78,
304 0xCC, 0xD0, 0xF4, 0xE8, 0xBC, 0xA0, 0x84, 0x98, 0xA8, 0xB4,
305 0x90, 0x8C, 0xD8, 0xC4, 0xE0, 0xFC, 0x48, 0x54, 0x70, 0x6C,
306 0x38, 0x24, 0x00, 0x1C, 0x74, 0x68, 0x4C, 0x50, 0x04, 0x18,
307 0x3C, 0x20, 0x94, 0x88, 0xAC, 0xB0, 0xE4, 0xF8, 0xDC, 0xC0,
308 0x0C, 0x10, 0x34, 0x28, 0x7C, 0x60, 0x44, 0x58, 0xEC, 0xF0,
309 0xD4, 0xC8, 0x9C, 0x80, 0xA4, 0xB8, 0xD0, 0xCC, 0xE8, 0xF4,
310 0xA0, 0xBC, 0x98, 0x84, 0x30, 0x2C, 0x08, 0x14, 0x40, 0x5C,
311 0x78, 0x64, 0xFC, 0xE0, 0xC4, 0xD8, 0x8C, 0x90, 0xB4, 0xA8,
312 0x1C, 0x00, 0x24, 0x38, 0x6C, 0x70, 0x54, 0x48, 0x20, 0x3C,
313 0x18, 0x04, 0x50, 0x4C, 0x68, 0x74, 0xC0, 0xDC, 0xF8, 0xE4,
314 0xB0, 0xAC, 0x88, 0x94, 0x58, 0x44, 0x60, 0x7C, 0x28, 0x34,
315 0x10, 0x0C, 0xB8, 0xA4, 0x80, 0x9C, 0xC8, 0xD4, 0xF0, 0xEC,
316 0x84, 0x98, 0xBC, 0xA0, 0xF4, 0xE8, 0xCC, 0xD0, 0x64, 0x78,
317 0x5C, 0x40, 0x14, 0x08, 0x2C, 0x30
318 };
319 public static byte[] Crc11(byte[] buffer, int start = 0, int len = 0)
320 {
321 if (buffer == null || buffer.Length == 0) return null;
322 if (start < 0) return null;
323 if (len == 0) len = buffer.Length - start;
324 int length = start + len;
325 if (length > buffer.Length) return null;
326 int i;
327 byte crc = 0x00;
328 int tableIndex;
329 for (i = start; i < length; i++)
330 {
331 tableIndex = crc ^ (buffer[i] & 0xFF);
332 crc = table[tableIndex];
333 }
334 return new byte[] { crc };
335 }
336 /// **********************************************************************
337 /// Name: CRC-12 x16+x12+x5+1
338 /// Poly: 0x80
339 /// Init: 0x0000
340 /// Refin: true
341 /// Refout: true
342 /// Xorout: 0x0000
343 ///*************************************************************************
344 public static byte[] Crc12(byte[] buffer, int start = 0, int len = 0)
345 {
346 if (buffer == null || buffer.Length == 0) return null;
347 if (start < 0) return null;
348 if (len == 0) len = buffer.Length - start;
349 int length = start + len;
350 if (length > buffer.Length) return null;
351 ushort crc = 0;// Initial value
352 short iQ = 0, iR = 0;
353 for (int i = start; i < length; i++)
354 {
355 // 多项式除法
356 // 如果该位为1
357 if ((buffer[i] & (0x80 >> iR)) > 0)
358 {
359 // 则在余数尾部添1否则添0
360 crc |= 0x01;
361 }
362 // 如果12位除数中的最高位为1，则够除
363 if (crc >= 0x1000)
364 {
365 crc ^= 0x180D;
366 }
367 crc <<= 1;
368 iR++;
369 if (8 == iR)
370 {
371 iR = 0;
372 iQ++;
373 }
374 }
375 // 对后面添加的12个0做处理
376 for (int i = 0; i < 12; i++)
377 {
378 if (crc >= 0x1000)
379 {
380 crc ^= 0x180D;
381 }
382 crc <<= 1;
383 }
384 crc >>= 1;
385 byte[] ret = BitConverter.GetBytes(crc);
386 Array.Reverse(ret);
387 return ret;
388 }
389 /// **********************************************************************
390 /// Name: CRC-16/CCITT x16+x12+x5+1
391 /// Poly: 0x1021
392 /// Init: 0x0000
393 /// Refin: true
394 /// Refout: true
395 /// Xorout: 0x0000
396 ///*************************************************************************
397 public static byte[] Crc13(byte[] buffer, int start = 0, int len = 0)
398 {
399 if (buffer == null || buffer.Length == 0) return null;
400 if (start < 0) return null;
401 if (len == 0) len = buffer.Length - start;
402 int length = start + len;
403 if (length > buffer.Length) return null;
404 ushort crc = 0;// Initial value
405 for (int i = start; i < length; i++)
406 {
407 crc ^= buffer[i];
408 for (int j = 0; j < 8; j++)
409 {
410 if ((crc & 1) > 0)
411 crc = (ushort)((crc >> 1) ^ 0x8408);// 0x8408 = reverse 0x1021
412 else
413 crc = (ushort)(crc >> 1);
414 }
415 }
416 byte[] ret = BitConverter.GetBytes(crc);
417 Array.Reverse(ret);
418 return ret;
419 }
420 /// **********************************************************************
421 /// Name: CRC-16/CCITT FALSE x16+x12+x5+1
422 /// Poly: 0x1021
423 /// Init: 0xFFFF
424 /// Refin: false
425 /// Refout: false
426 /// Xorout: 0x0000
427 ///*************************************************************************
428 public static byte[] Crc14(byte[] buffer, int start = 0, int len = 0)
429 {
430 if (buffer == null || buffer.Length == 0) return null;
431 if (start < 0) return null;
432 if (len == 0) len = buffer.Length - start;
433 int length = start + len;
434 if (length > buffer.Length) return null;
435 ushort crc = 0xFFFF;// Initial value
436 for (int i = start; i < length; i++)
437 {
438 crc ^= (ushort)(buffer[i] << 8);
439 for (int j = 0; j < 8; j++)
440 {
441 if ((crc & 0x8000) > 0)
442 crc = (ushort)((crc << 1) ^ 0x1021);
443 else
444 crc = (ushort)(crc << 1);
445 }
446 }
447 byte[] ret = BitConverter.GetBytes(crc);
448 Array.Reverse(ret);
449 return ret;
450 }
451 /// **********************************************************************
452 /// Name: CRC-16/DNP x16+x13+x12+x11+x10+x8+x6+x5+x2+1
453 /// Poly: 0x3D65
454 /// Init: 0x0000
455 /// Refin: true
456 /// Refout: true
457 /// Xorout: 0xFFFF
458 ///*************************************************************************
459 public static byte[] Crc15(byte[] buffer, int start = 0, int len = 0)
460 {
461 if (buffer == null || buffer.Length == 0) return null;
462 if (start < 0) return null;
463 if (len == 0) len = buffer.Length - start;
464 int length = start + len;
465 if (length > buffer.Length) return null;
466 ushort crc = 0;// Initial value
467 for (int i = start; i < length; i++)
468 {
469 crc ^= buffer[i];
470 for (int j = 0; j < 8; j++)
471 {
472 if ((crc & 1) > 0)
473 crc = (ushort)((crc >> 1) ^ 0xA6BC);// 0xA6BC = reverse 0x3D65
474 else
475 crc = (ushort)(crc >> 1);
476 }
477 }
478 byte[] ret = BitConverter.GetBytes((ushort)~crc);
479 Array.Reverse(ret);
480 return ret;
481 }
482 /// **********************************************************************
483 /// Name: CRC-16/IBM x16+x15+x2+1
484 /// Poly: 0x8005
485 /// Init: 0x0000
486 /// Refin: true
487 /// Refout: true
488 /// Xorout: 0x0000
489 ///*************************************************************************
490 public static byte[] Crc16(byte[] buffer, int start = 0, int len = 0)
491 {
492 if (buffer == null || buffer.Length == 0) return null;
493 if (start < 0) return null;
494 if (len == 0) len = buffer.Length - start;
495 int length = start + len;
496 if (length > buffer.Length) return null;
497 ushort crc = 0;// Initial value
498 for (int i = start; i < length; i++)
499 {
500 crc ^= buffer[i];
501 for (int j = 0; j < 8; j++)
502 {
503 if ((crc & 1) > 0)
504 crc = (ushort)((crc >> 1) ^ 0xA001);// 0xA001 = reverse 0x8005
505 else
506 crc = (ushort)(crc >> 1);
507 }
508 }
509 byte[] ret = BitConverter.GetBytes(crc);
510 Array.Reverse(ret);
511 return ret;
512 }
513 /// **********************************************************************
514 /// Name: CRC-16/MAXIM x16+x15+x2+1
515 /// Poly: 0x8005
516 /// Init: 0x0000
517 /// Refin: true
518 /// Refout: true
519 /// Xorout: 0xFFFF
520 ///*************************************************************************
521 public static byte[] Crc17(byte[] buffer, int start = 0, int len = 0)
522 {
523 if (buffer == null || buffer.Length == 0) return null;
524 if (start < 0) return null;
525 if (len == 0) len = buffer.Length - start;
526 int length = start + len;
527 if (length > buffer.Length) return null;
528 ushort crc = 0;// Initial value
529 for (int i = start; i < length; i++)
530 {
531 crc ^= buffer[i];
532 for (int j = 0; j < 8; j++)
533 {
534 if ((crc & 1) > 0)
535 crc = (ushort)((crc >> 1) ^ 0xA001);// 0xA001 = reverse 0x8005
536 else
537 crc = (ushort)(crc >> 1);
538 }
539 }
540 byte[] ret = BitConverter.GetBytes((ushort)~crc);
541 Array.Reverse(ret);
542 return ret;
543 }
544 /// **********************************************************************
545 /// Name: CRC-16/MODBUS x16+x15+x2+1
546 /// Poly: 0x8005
547 /// Init: 0xFFFF
548 /// Refin: true
549 /// Refout: true
550 /// Xorout: 0x0000
551 ///*************************************************************************
552 public static byte[] Crc18(byte[] buffer, int start = 0, int len = 0)
553 {
554 if (buffer == null || buffer.Length == 0) return null;
555 if (start < 0) return null;
556 if (len == 0) len = buffer.Length - start;
557 int length = start + len;
558 if (length > buffer.Length) return null;
559 ushort crc = 0xFFFF;// Initial value
560 for (int i = start; i < length; i++)
561 {
562 crc ^= buffer[i];
563 for (int j = 0; j < 8; j++)
564 {
565 if ((crc & 1) > 0)
566 crc = (ushort)((crc >> 1) ^ 0xA001);// 0xA001 = reverse 0x8005
567 else
568 crc = (ushort)(crc >> 1);
569 }
570 }
571 byte[] ret = BitConverter.GetBytes(crc);
572 Array.Reverse(ret);
573 return ret;
574 }
575 /// **********************************************************************
576 /// Name: CRC-16/USB x16+x15+x2+1
577 /// Poly: 0x8005
578 /// Init: 0xFFFF
579 /// Refin: true
580 /// Refout: true
581 /// Xorout: 0xFFFF
582 ///*************************************************************************
583 public static byte[] Crc19(byte[] buffer, int start = 0, int len = 0)
584 {
585 if (buffer == null || buffer.Length == 0) return null;
586 if (start < 0) return null;
587 if (len == 0) len = buffer.Length - start;
588 int length = start + len;
589 if (length > buffer.Length) return null;
590 ushort crc = 0xFFFF;// Initial value
591 for (int i = start; i < length; i++)
592 {
593 crc ^= buffer[i];
594 for (int j = 0; j < 8; j++)
595 {
596 if ((crc & 1) > 0)
597 crc = (ushort)((crc >> 1) ^ 0xA001);// 0xA001 = reverse 0x8005
598 else
599 crc = (ushort)(crc >> 1);
600 }
601 }
602 byte[] ret = BitConverter.GetBytes((ushort)~crc);
603 Array.Reverse(ret);
604 return ret;
605 }
606 /// **********************************************************************
607 /// Name: CRC-16/X25 x16+x12+x5+1
608 /// Poly: 0x1021
609 /// Init: 0xFFFF
610 /// Refin: true
611 /// Refout: true
612 /// Xorout: 0xFFFF
613 ///*************************************************************************
614 public static byte[] Crc20(byte[] buffer, int start = 0, int len = 0)
615 {
616 if (buffer == null || buffer.Length == 0) return null;
617 if (start < 0) return null;
618 if (len == 0) len = buffer.Length - start;
619 int length = start + len;
620 if (length > buffer.Length) return null;
621 ushort crc = 0xFFFF;// Initial value
622 for (int i = start; i < length; i++)
623 {
624 crc ^= buffer[i];
625 for (int j = 0; j < 8; j++)
626 {
627 if ((crc & 1) > 0)
628 crc = (ushort)((crc >> 1) ^ 0x8408);// 0x8408 = reverse 0x1021
629 else
630 crc = (ushort)(crc >> 1);
631 }
632 }
633 byte[] ret = BitConverter.GetBytes((ushort)~crc);
634 Array.Reverse(ret);
635 return ret;
636 }
637 /// **********************************************************************
638 /// Name: CRC-16/XMODEM x16+x12+x5+1
639 /// Poly: 0x1021
640 /// Init: 0x0000
641 /// Refin: false
642 /// Refout: false
643 /// Xorout: 0x0000
644 ///*************************************************************************
645 public static byte[] Crc21(byte[] buffer, int start = 0, int len = 0)
646 {
647 if (buffer == null || buffer.Length == 0) return null;
648 if (start < 0) return null;
649 if (len == 0) len = buffer.Length - start;
650 int length = start + len;
651 if (length > buffer.Length) return null;
652 ushort crc = 0;// Initial value
653 for (int i = start; i < length; i++)
654 {
655 crc ^= (ushort)(buffer[i] << 8);
656 for (int j = 0; j < 8; j++)
657 {
658 if ((crc & 0x8000) > 0)
659 crc = (ushort)((crc << 1) ^ 0x1021);
660 else
661 crc = (ushort)(crc << 1);
662 }
663 }
664 byte[] ret = BitConverter.GetBytes(crc);
665 Array.Reverse(ret);
666 return ret;
667 }
668 /// **********************************************************************
669 /// Name: CRC32 x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
670 /// Poly: 0x04C11DB7
671 /// Init: 0xFFFFFFFF
672 /// Refin: true
673 /// Refout: true
674 /// Xorout: 0xFFFFFFFF
675 ///*************************************************************************
676 public static byte[] Crc22(byte[] buffer, int start = 0, int len = 0)
677 {
678 if (buffer == null || buffer.Length == 0) return null;
679 if (start < 0) return null;
680 if (len == 0) len = buffer.Length - start;
681 int length = start + len;
682 if (length > buffer.Length) return null;
683 uint crc = 0xFFFFFFFF;// Initial value
684 for (int i = start; i < length; i++)
685 {
686 crc ^= buffer[i];
687 for (int j = 0; j < 8; j++)
688 {
689 if ((crc & 1) > 0)
690 crc = (crc >> 1) ^ 0xEDB88320;// 0xEDB88320= reverse 0x04C11DB7
691 else
692 crc = crc >> 1;
693 }
694 }
695 byte[] ret = BitConverter.GetBytes(~crc);
696 Array.Reverse(ret);
697 return ret;
698 }
699 /// **********************************************************************
700 /// Name: CRC32/MPEG-2 x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
701 /// Poly: 0x04C11DB7
702 /// Init: 0xFFFFFFFF
703 /// Refin: false
704 /// Refout: false
705 /// Xorout: 0x00000000
706 ///*************************************************************************
707 public static byte[] Crc23(byte[] buffer, int start = 0, int len = 0)
708 {
709 if (buffer == null || buffer.Length == 0) return null;
710 if (start < 0) return null;
711 if (len == 0) len = buffer.Length - start;
712 int length = start + len;
713 if (length > buffer.Length) return null;
714 uint crc = 0xFFFFFFFF;// Initial value
715 for (int i = start; i < length; i++)
716 {
717 crc ^= (uint)(buffer[i] << 24);
718 for (int j = 0; j < 8; j++)
719 {
720 if ((crc & 0x80000000) > 0)
721 crc = (crc << 1) ^ 0x04C11DB7;
722 else
723 crc = crc << 1;
724 }
725 }
726 byte[] ret = BitConverter.GetBytes(crc);
727 Array.Reverse(ret);
728 return ret;
729 }
纵向冗余校验（Longitudinal Redundancy Check，简称：LRC）是通信中常用的一种校验形式，也称LRC校验或纵向校验。 它是一种从纵向通道上的特定比特串产生校验比特的错误检测方法。在行列格式中（如磁带），LRC经常是与VRC一起使用，这样就会为每个字符校验码。在工业领域Modbus协议Ascii模式采用该算法。 LRC计算校验码,具体算法如下：
/// 1、对需要校验的数据（2n个字符）两两组成一个16进制的数值求和。
/// 2、将求和结果与256求模。
/// 3、用256减去所得模值得到校验结果（另一种方法：将模值按位取反然后加1）。
1 public static byte[] Lrc(byte[] buffer, int start = 0, int len = 0)
2 {
3 if (buffer == null || buffer.Length == 0) return null;
4 if (start < 0) return null;
5 if (len == 0) len = buffer.Length - start;
6 int length = start + len;
7 if (length > buffer.Length) return null;
8 byte lrc = 0;// Initial value
9 for (int i = start; i < len; i++)
10 {
11 lrc += buffer[i];
12 }
13 lrc = (byte)((lrc ^ 0xFF) + 1);
14 return new byte[] { lrc };
15 }
BCC(Block Check Character/信息组校验码)，因校验码是将所有数据异或得出，故俗称异或校验。具体算法是：将每一个字节的数据（一般是两个16进制的字符）进行异或后即得到校验码。
public static byte[] Bcc(byte[] buffer, int start = 0, int len = 0)
{
if (buffer == null || buffer.Length == 0) return null;
if (start < 0) return null;
if (len == 0) len = buffer.Length - start;
int length = start + len;
if (length > buffer.Length) return null;
byte bcc = 0;// Initial value
for (int i = start; i < len; i++)
{
bcc ^= buffer[i];
}
return new byte[] { bcc };
}
检验和(checksum)，在数据处理和数据通信领域中，用于校验目的地一组数据项的和。它通常是以十六进制为数制表示的形式。如果校验和的数值超过十六进制的FF,也就是255. 就要求其补码作为校验和。通常用来在通信中，尤其是远距离通信中保证数据的完整性和准确性。
1 public static byte[] allAdd(byte[] buffer, int start = 0, int len = 0)
2 {
3 if (buffer == null || buffer.Length == 0) return null;
4 if (start < 0) return null;
5 if (len == 0) len = buffer.Length - start;
6 int length = start + len;
7 if (length > buffer.Length) return null;
8 byte bcc = 0;// Initial value
9 for (int i = start; i < len; i++)
10 {
11 bcc ^= buffer[i];
12 }
13 return new byte[] { bcc };
14 }
