C# Crc 取循环冗余校验码

最新推荐文章于 2022-03-18 21:18:29 发布
最新推荐文章于 2022-03-18 21:18:29 发布
阅读量2.5k 收藏
点赞数
分类专栏： C# 文章标签： CRC crc

[代码] Crc 取循环冗余校验码

001 /**********************************************************
002  * CJF Development Library for Microsoft.NET
003  * Note：crc
004  * Create Date：2011-11-15
005  * Author：崔俊峰
006  * Copyright (c) 2012,2015 Cjf Studio.China
007  * All Rigths Reserved!
008 **********************************************************/
009  
010 using System;
011 using System.Text;
012  
013 namespace Cjf.Components.Security.Crc
014 {
015     public interface ICRC
016     {
017         long GetCrc(int bval);
018         long GetCrc(string str);
019         long GetCrc(byte[] buffer);
020         long GetCrc(byte[] buffer, int offset, int count);
021     }
022  
023     /// <summary>
024     /// CRC8 的摘要说明。
025     /// </summary>
026     public class CRC8 : ICRC
027     {
028         readonly byte CrcSeed = 0xFF;
029         #region CRC 8 位校验表
030         /// <summary>
031         /// CRC 8 位校验表
032         /// </summary>
033         public byte[] CRC8_Table = new byte[]
034   {
035    0,94,188,226,97,63,221,131,194,156,126,32,163,253,31,65,
036    157,195,33,127,252,162,64,30, 95,1,227,189,62,96,130,220,
037    35,125,159,193,66,28,254,160,225,191,93,3,128,222,60,98,
038    190,224,2,92,223,129,99,61,124,34,192,158,29,67,161,255,
039    70,24,250,164,39,121,155,197,132,218,56,102,229,187,89,7,            
040    219,133,103,57,186,228,6,88,25,71,165,251,120,38,196,154,
041    101,59,217,135,4,90,184,230,167,249,27,69,198,152,122,36,                        
042    248,166,68,26,153,199,37,123,58,100,134,216,91,5,231,185,            
043    140,210,48,110,237,179,81,15,78,16,242,172,47,113,147,205,
044    17,79,173,243,112,46,204,146,211,141,111,49,178,236,14,80,
045    175,241,19,77,206,144,114,44,109,51,209,143,12,82,176,238,
046    50,108,142,208,83,13,239,177,240,174,76,18,145,207,45,115,
047    202,148,118,40,171,245,23,73,8,86,180,234,105,55,213,139,
048    87,9,235,181,54,104,138,212,149,203, 41,119,244,170,72,22,
049    233,183,85,11,136,214,52,106,43,117,151,201,74,20,246,168,
050    116,42,200,150,21,75,169,247,182,232,10,84,215,137,107,53
051   };
052         #endregion
053  
054         byte crc = 0;
055  
056         /// <summary>
057         /// 构造函数
058         /// </summary>
059         public CRC8()
060         {
061         }
062  
063         /// <summary>
064         /// 8位CRC校验 产生校验码 需要被校验码和校验码
065         /// </summary>
066         /// <param name="OldCRC">旧的校验码</param>
067         /// <param name="bval">被校验码</param>
068         /// <returns> 产生校验码</returns>
069         public byte ComputeCrc(byte oldCrc, byte bval)
070         {
071             return CRC8_Table[oldCrc ^ bval];
072         }
073  
074         /// <summary>
075         /// 8位CRC校验 产生校验码 只要被校验码
076         /// </summary>
077         /// <param name="bval"></param>
078         /// <returns>返回校验码</returns>
079         public long GetCrc(int bval)
080         {
081             crc = CrcSeed;
082             crc = CRC8_Table[crc ^ (bval & 0XFF)];
083             crc ^= CrcSeed;
084             return crc;
085         }
086  
087         /// <summary>
088         /// 要校验的字符串
089         /// </summary>
090         /// <param name="str"></param>
091         /// <returns>成功:返回校验码；失败：-1表示参数错误</returns>
092         public long GetCrc(string str)
093         {
094             if (String.IsNullOrEmpty(str))
095                 return -1;
096             return GetCrc(Encoding.Unicode.GetBytes(str));
097         }
098  
099         /// <summary>
100         /// 8位CRC校验 产生校验码 只要被校验的字节数组
101         /// </summary>
102         /// <param name="buffer"></param>
103         /// <returns>成功:返回校验码；失败：-1表示参数错误</returns>
104         public long GetCrc(byte[] buffer)
105         {
106             return GetCrc(buffer, 0, buffer.Length);
107         }
108  
109         /// <summary>
110         /// 8 位 CRC 校验 产生校验码 要被校验的字节数组、起始结果位置和字节长度
111         /// </summary>
112         /// <param name="buffer"></param>
113         /// <param name="offset"></param>
114         /// <param name="count"></param>
115         /// <returns>成功:返回校验码；失败：-1表示参数错误</returns>
116         public long GetCrc(byte[] buffer, int offset, int count)
117         {
118             if (buffer == null || buffer.Length < 1 || offset < 0 || offset >= buffer.Length || count < 1)
119                 return -1;
120             //crc ^= CrcSeed;
121             crc = CrcSeed;
122             for (int i = offset; i < count; i++)
123             {
124                 crc = CRC8_Table[crc ^ buffer[i]];
125             }
126             crc ^= CrcSeed;
127             return crc;
128         }
129     }
130  
131     /// <summary>
132     /// CRC16 的摘要说明。
133     /// </summary>
134     public class CRC16 : ICRC
135     {
136         readonly ushort CrcSeed = 0xFFFF;
137         #region CRC 16 位校验表
138  
139         /// <summary>
140         /// 16 位校验表 Upper 表
141         /// </summary>
142         public ushort[] uppercrctab = new ushort[]
143    {
144     0x0000,0x1231,0x2462,0x3653,0x48c4,0x5af5,0x6ca6,0x7e97,
145     0x9188,0x83b9,0xb5ea,0xa7db,0xd94c,0xcb7d,0xfd2e,0xef1f
146    };
147  
148         /// <summary>
149         /// 16 位校验表 Lower 表
150         /// </summary>
151         public ushort[] lowercrctab = new ushort[]
152    {
153     0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
154     0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef
155    };
156         #endregion
157  
158         ushort crc = 0;
159  
160         /// <summary>
161         /// 构造函数
162         /// </summary>
163         public CRC16()
164         {
165         }
166  
167         /// <summary>
168         /// 16位CRC校验 产生校验码 需要被校验码和校验码
169         /// </summary>
170         /// <param name="oldCrc">旧的校验码</param>
171         /// <param name="bval">被校验码</param>
172         /// <returns>返回校验码</returns>
173         public uint ComputeCrc(ushort oldCrc, byte bval)
174         {
175             crc = oldCrc;
176             return Get_Crc(bval);
177         }
178  
179         /// <summary>
180         /// 16位CRC校验 产生校验码 只要被校验码
181         /// </summary>
182         /// <param name="bval"></param>
183         /// <returns>返回校验码</returns>
184         public long GetCrc(int bval)
185         {
186             crc = CrcSeed;
187             crc = Get_Crc(bval);
188             crc ^= CrcSeed;
189             return crc;
190         }
191  
192         /// <summary>
193         /// 16位CRC校验 产生校验码 只要被校验码
194         /// </summary>
195         /// <param name="bval"></param>
196         /// <returns>返回校验码</returns>
197         private ushort Get_Crc(int bval)
198         {
199             ushort h = (ushort)((crc >> 12) & 0x0f);
200             ushort l = (ushort)((crc >> 8) & 0x0f);
201             ushort temp = crc;
202             temp = (ushort)(((temp & 0x00ff) << 8) | bval);
203             temp = (ushort)(temp ^ (uppercrctab[(h - 1) + 1] ^ lowercrctab[(l - 1) + 1]));
204             crc = temp;
205             return crc;
206         }
207  
208         /// <summary>
209         /// 要校验的字符串
210         /// </summary>
211         /// <param name="str"></param>
212         /// <returns>成功:返回校验码；失败：-1表示参数错误</returns>
213         public long GetCrc(string str)
214         {
215             if (String.IsNullOrEmpty(str))
216                 return -1;
217             return GetCrc(Encoding.Unicode.GetBytes(str));
218         }
219  
220         /// <summary>
221         /// 16位CRC校验 产生校验码 只要被校验的字节数组
222         /// </summary>
223         /// <param name="buffer"></param>
224         /// <returns>成功:返回校验码；失败：-1表示参数错误</returns>
225         public long GetCrc(byte[] buffer)
226         {
227             return GetCrc(buffer, 0, buffer.Length);
228         }
229  
230         /// <summary>
231         /// Crc16
232         /// </summary>
233         /// <param name="buffer"></param>
234         /// <param name="offset"></param>
235         /// <param name="count"></param>
236         /// <returns>成功:返回校验码；失败：-1表示参数错误</returns>
237         public long GetCrc(byte[] buffer, int offset, int count)
238         {
239             if (buffer == null || buffer.Length < 1 || offset < 0 || offset >= buffer.Length || count < 1)
240                 return -1;
241             crc = CrcSeed;
242             for (int i = offset; i < count; i++)
243             {
244                 Get_Crc(buffer[i]);
245             }
246             crc ^= CrcSeed;
247             return crc;
248         }
249  
250     }
251  
252     /// <summary>
253     /// CRC32 的摘要说明。
254     /// </summary>
255     public class CRC32 : ICRC
256     {
257         readonly static uint CrcSeed = 0xFFFFFFFF;
258         readonly static uint[] CrcTable = new uint[] {
259                    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419,
260                    0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4,
261                    0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07,
262                    0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
263                    0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856,
264                    0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
265                    0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
266                    0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
267                    0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3,
268                    0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A,
269                    0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599,
270                    0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
271                    0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190,
272                    0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
273                    0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E,
274                    0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
275                    0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED,
276                    0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
277                    0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3,
278                    0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
279                    0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
280                    0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
281                    0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010,
282                    0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
283                    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17,
284                    0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6,
285                    0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615,
286                    0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
287                    0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344,
288                    0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
289                    0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A,
290                    0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
291                    0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1,
292                    0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C,
293                    0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
294                    0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
295                    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE,
296                    0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31,
297                    0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C,
298                    0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
299                    0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B,
300                    0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
301                    0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1,
302                    0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
303                    0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278,
304                    0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7,
305                    0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66,
306                    0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
307                    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
308                    0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8,
309                    0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B,
310                    0x2D02EF8D
311                   };
312  
313  
314         uint crc = 0;
315  
316         /// <summary>
317         /// 构造函数
318         /// </summary>
319         public CRC32()
320         {
321         }
322  
323         /// <summary>
324         /// 32位CRC校验 产生校验码 需要被校验码和校验码
325         /// </summary>
326         /// <param name="oldCrc">旧的校验码</param>
327         /// <param name="bval">被校验码</param>
328         /// <returns>返回校验码</returns>
329         public long ComputeCrc(uint oldCrc, byte bval)
330         {
331             return CrcTable[(oldCrc ^ bval) & 0xFF] ^ (oldCrc >> 8);
332         }
333  
334         /// <summary>
335         /// 32位CRC校验 产生校验码 只要被校验码
336         /// </summary>
337         /// <param name="bval"></param>
338         /// <returns>返回校验码</returns>
339         public long GetCrc(int bval)
340         {
341             crc = CrcSeed;
342             crc = CrcTable[(crc ^ bval) & 0xFF] ^ (crc >> 8);
343             crc ^= CrcSeed;
344             return crc;
345         }
346  
347         /// <summary>
348         /// 要校验的字符串
349         /// </summary>
350         /// <param name="str"></param>
351         /// <returns>成功:返回校验码；失败：-1表示参数错误</returns>
352         public long GetCrc(string str)
353         {
354             if (String.IsNullOrEmpty(str))
355                 return -1;
356             return GetCrc(Encoding.Unicode.GetBytes(str));
357         }
358  
359         /// <summary>
360         /// 32位CRC校验 产生校验码 只要被校验的字节数组
361         /// </summary>
362         /// <param name="buffer"></param>
363         /// <returns>成功:返回校验码；失败：-1表示参数错误</returns>
364         public long GetCrc(byte[] buffer)
365         {
366             return GetCrc(buffer, 0, buffer.Length);
367         }
368  
369         /// <summary>
370         /// 32位 CRC 校验 产生校验码 要被校验的字节数组、起始结果位置和字节长度
371         /// </summary>
372         /// <param name="buffer"></param>
373         /// <param name="offset"></param>
374         /// <param name="count"></param>
375         /// <returns>成功:返回校验码；失败：-1表示参数错误</returns>
376         public long GetCrc(byte[] buffer, int offset, int count)
377         {
378             if (buffer == null || buffer.Length < 1 || offset < 0 || offset >= buffer.Length || count < 1)
379                 return -1;
380             crc = CrcSeed;
381             while (--count >= 0)
382             {
383                 crc = CrcTable[(crc ^ buffer[offset++]) & 0xFF] ^ (crc >> 8);
384             }
385             crc ^= CrcSeed;
386             return crc;
387         }
388     }
389 }

转自：http://www.oschina.net/code/snippet_572249_11777

逍遥子(｡ˇε ˇ｡）
关注
专栏目录
C#串口通信从入门到精通（24）——循环冗余校验（CRC）原理与C#代码实现
qq_34059233的博客
05-18 1717
本文详细介绍循环冗余校验算法（CRC）的原理以及C#代码实现，并以ModbusRtu中使用的CRC16校验为例子，介绍了其C#代码的实现，由多年实战经验总结，绝对干货！
C#实现CRC循环冗余校验
12-04
C#语言实现CRC循环冗余校验 有源码程序
C# CRC 循环冗余校验算法
09-27
C# CRC 循环冗余校验算法，包含8位 16位 32位 三种校验算法。 本例直接简单易懂，通过点击按钮直接 产生字符串“ABCD”的CRC32校验码“DB1720A5”，并将校验码显示在下面的文本框中。
C#：循环冗余校验CRC-16-CCITT和CRC-32-IEEE 802.3
老瓦的笔记本
02-28 5147
作者：Splash 转自：http://blog.csdn.net/jhqin/article/details/6973292 CRC-16-CCITT [csharp] view plaincopy /* ---------------------------------------------------------- 文件名称：CRC16.
循环冗余校验码（CRC16）
12-27
CRC是数据通信领域中最常用的一种查错校验码，其特征是信息字段和校验字段的长度可以任意选定。循环冗余检查（CRC）是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性和完整性。
关于CRC循环冗余校验的总结（C#）
weixin_30426957的博客
04-06 232
1.实验要求 (1)通过CRC（循环冗余校对）序列的计算，掌握C#语言中类的静态方法与动态方法的区别。 (2)Shell与WindowsForm的通信作为扩展提高内容。 2.实验内容 主要工作是：设计算法实现CRC序列的计算 CRC的计算过程总结如下： 1、设置CRC寄存器，并给其赋值0xffff； ...
C# CRC 16 校验码生成
04-17
CRC（Cyclic Redundancy Check，循环冗余校验）是一种广泛用于数据传输错误检测的校验码技术，尤其在串行通信、网络协议、存储系统等领域应用颇广。CRC16是CRC的一种，它使用16位的校验码。在C#中实现CRC16校验码...
C#,Java,C -循环冗余检验：CRC-16-CCITT查表法
weixin_34357887的博客
09-26 284
C#代码 1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 6 namespace TestCRC 7 { 8 /// &lt;summary&gt; 9 /// 循环冗余检...
循环冗余检验
hust_wh的专栏
09-18 2610
循环冗余检验循环冗余校验 CRC的算法分析和程序实现西南交通大学计算机与通信工程学院  刘东 摘要   通信的目的是要把信息及时可靠地传送给对方，因此要求一个通信系统传输消息必须可靠与快速，在数字通信系统中可靠与快速往往是一对矛盾。为了解决可靠性，通信系统都采用了差错控制。本文详细介绍了循环冗余校验CRC（Cyclic Redundancy Check）的差错控制原理及其算法实现。
CRC循环冗余校验_C#版
03-30
完整的类代码,包括一个接口,8\16\32位三个类，分别实现，可视需求删减其中的类。
C#写的CRC16校验算法
08-31
C#写的CRC16校验算法，分为CRC16和ModbusCRC16两种，使用方法请参考Demo
C# 实现CRC校验（循环冗余校验）CRC-8位/16位/32位等参数模型
猿长大人
03-18 4328
C# 实现CRC校验（循环冗余校验）CRC-8位/16位/32位等参数模型
循环冗余检验CRC C#代码 Crc32
qq826364410的专栏
06-19 1870
CRC简介 循环冗余校验(Cyclic Redundancy Check, CRC)是一种根据网络数据包或电脑文件等数据产生简短固定位数校验码的一种散列函数，主要用来检测或校验数据传输或者保存后可能出现的错误。它是利用除法及余数的原理来作错误侦测的。 在数据传输过程中，无论传输系统的设计再怎么完美，差错总会存在，这种差错可能会导致在链路上传输的一个或者多个帧被破坏(出现比特差错，0变为
java crc16 查表_C#,Java,C -循环冗余检验：CRC-16-CCITT查表法
weixin_39677538的博客
02-19 356
1 using System;2 using System.Collections.Generic;3 using System.Linq;4 using System.Text;56 namespace GovConsoleSuperior.Common7 {8 /// 9 /// 循环冗余检验：CRC-16-CCITT查表法10 /// 11 public st...
CRC循环冗余校验详解
weixin_43224412的博客
10-03 651
CRC循环冗余校验详解简介CRC手动演算CRC的直观运算过程 简介 https://www.bilibili.com/video/BV1V4411Z7VA?from=search&seid=3373767585328853317&spm_id_from=333.337.0.0 这个视频里讲的很明了透彻，本文章主要是对该视频内容做的笔记。 CRC手动演算 CRC的直观运算过程 ...
C#源码——CRC16循环冗余校验码的实现
dz_huanbao的专栏
11-16 1970
// 计算字节流数据的CRC值，crcOrigin使得CRC结果可以累积运算 public static ushort CRC16(byte[] data, ushort crcOrigin){    ushort crcResult = crcOrigin;    ushort crcExpress = 0x1021; // CRC16 expression   
CRC算法介绍
小侯的开发专栏
07-30 5317
在数字通信系统中可靠与快速往往是一对矛盾。若要求快速，则必然使得每个数据码元所占地时间缩短、波形变窄、能量减少，从而在受到干扰后产生错误地可能性增加，传送信息地可靠性下降。若是要求可靠，则使得传送消息地速率变慢。因此，如何合理地解决可靠性也速度这一对矛盾，是正确设计一个通信系统地关键问题之一。为保证传输过程的正确性，需要对通信过程进行差错控制。差错控制最常用的方法是自动请求重发方式（ARQ）、向前
循环冗余校验 CRC 的算法分析和程序实现
l00109503的专栏
03-27 886
摘要 通信的目的是要把信息及时可靠地传送给对方，因此要求一个通信系统传输消息必须可靠与快速，在数字通信系统中可靠与快速往往是一对矛盾。为了解决可靠性，通信系统都采用了差错控制。本文详细介绍了循环冗余校验CRC（Cyclic Redundancy Check）的差错控制原理及其算法实现。关键字 通信 循环冗余校验 CRC-32 CRC-16 CRC-4概述在数字通信系统中可靠与快速往往是一对矛盾。若
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值