CRC循环冗余码原理简述及python代码实现
CRC循环冗余码在计算机组成原理和计算机网络中都有重要的地位，但也不太好懂。

本人通过华南理工大学袁华老师的计算机网络（中国大学mooc平台）课程对CRC编码有了一点肤浅的认识，结合自己踩过的一些坑，最后给出CRC循环冗余码的python实现，希望能对想了解CRC编码的同学有点帮助。本文中引用了袁华老师课件中的图片，侵删。
如对程序实现感兴趣可直接跳过前面内容
要理解CRC的运算过程，先要了解模2运算，这是CRC编码中的运算规则。



简单来说，模2运算就是对两个长度相同的二进制数进行异或运算。
接下来给出一个简单的CRC编码的实例



在需要加密的数据（图片里是一个数据桢）后面添加（除数位数-1）位的0，用这个数对除数做模2除法。并把最后得到的余数加到原始帧的后面，得到编码后的数据。


这个图片做了详细介绍
接下来是解码过程



解码过程和加密过程类似，用需要解码的数据对除数做模2除法，如果余数为0，则代码没有检测出错误（有可能发生了错误但刚好余数也为0）

如此可以完成CRC的编码和解码过程。
接下来是python代码实现。
def XOR(str1, str2):    #实现模2减法
    ans = ''
    if str1[0] == '0':
        return '0', str1[1:]
    else:
        for i in range(len(str1)):
            if (str1[i] == '0' and str2[i] == '0'):
                ans = ans + '0'
            elif (str1[i] == '1' and str2[i] == '1'):
                ans = ans + '0'
            else:
                ans = ans + '1'
    return '1', ans[1:]
                

def CRC_Encoding(str1,str2):    #CRC编码
    lenght = len(str2)
    str3 = str1 + '0'*(lenght-1)
    ans = ''
    yus = str3[0:lenght]
    for i in range(len(str1)):
        str4,yus = XOR(yus, str2)
        ans = ans+str4
        if i == len(str1)-1:
            break
        else:
            yus = yus+str3[i+lenght]
    ans = str1 + yus
    return ans

def CRC_Decoding(str1,str2):    #CRC解码
    lenght = len(str2)
    str3 = str1 + '0'*(lenght-1)
    ans = ''
    yus = str3[0:lenght]
    for i in range(len(str1)):
        str4,yus = XOR(yus, str2)
        ans = ans+str4
        if i == len(str1)-1:
            break
        else:
            yus = yus+str3[i+lenght]
    return yus == '0'*len(yus)

def main():    #主函数
    while True:
        print('=='*30)
        setting = input("请输入运行模式（0：退出，1：CRC编码，2：CRC验证）：")
        if setting == '0':
            break
        elif setting == '1':
            str1 = input("请输入数据：")
            str2 = input("请输入生成比特模式：")
            str3 = CRC_Encoding(str1,str2)
            print("{} 编码后为: {}".format(str1,str3))
        elif setting == '2':
            str1 = input("请输入验证数据：")
            str2 = input("请输入生成比特模式：")
            flag = CRC_Decoding(str1,str2)
            if flag:
                print("验证完成，未出错")
            else:
                print("sorry 验证数据已出错")
        else:
            print("请正确输入：")

main()

好了，这就是我对CRC编码的了解，希望能对你有所帮助。代码实现可以帮助你验证你的计算是否错误，仅做学习用途。

原文网址：http://blog.csdn.net/zhangqc1985/article/details/2955965


一。 

　　在远距离数据通信中，为确保高效而无差错地传送数据，必须对数据进行校验即差错控制。循环冗余校验CRC(Cyclic   Redundancy   Check)是对一个传送数据块进行校验，是一种高效的差错控制方法。   

    

  1　循环冗余校验码原理   

    

  　　CRC校验采用多项式编码方法，如一个8位二进制数(B7B6B5B4B3B2B1B0)可以用7阶二进制码多项式B7X7+B6X6+B5X5+B4X4+B3X3+B2X2+B1X1+B0X0表示。   

  　　例如11000001可表示为   

  　　1X7+1X6+0X5+0X4+0X3+0X2+0X1+0X0   

  　　一般说，n位二进制数可用(n-1)阶多项式表示。它把要发送的数据位串看成是系数只能为“1”或“0”的多项式。一个n位的数据块可以看成是从Xn-1到X0的n项多项式的系数序列，位于数据块左边的最高位是Xn-1项的系数，次高位是Xn-2项的系数，依此类推，位于数据块右边的最低位是X0项的系数，这个多项式的阶数为n-1。   

  　　多项式乘除法运算过程与普通代数多项式的乘除法相同。多项式的加减法运算以2为模，加减时不进、错位，如同逻辑异或运算。   

  　　采用CRC校验时，发送方和接收方事先约定一个生成多项式G(X)，并且G(X)的最高项和最低项的系数必须为1。设m位数据块的多项式为M(X)，生成多项式G(X)的阶数必需比M(X)的阶数低。CRC校验码的检错原理是：发送方先为数据块生成CRC校验码，使这个CRC校验码的多项式能被G(X)除尽，实际发送此CRC校验码；接收方用收到的CRC校验码除以G(X)，如果能除尽，表明传输正确，否则，表示有传输错误，请求重发。   

  　　生成数据块的CRC校验码的方法是：   

  　　(1)   设G(X)为r阶，在数据块末尾添加r个0，使数据块为m+r位，则相应的多项式为XrM(X)；   

  　　(2)   以2为模，用对应于G(X)的位串去除对应于XrM(X)的位串，求得余数位串；   

  　　(3)   以2为模，从对应于XrM(X)的位串中减去余数位串，结果就是为数据块生成的带足够校验信息的CRC校验码位串。   

  　　例如，设要发送的数据为1101011011，G(X)=X4+X+1，则首先在发送数据块的末尾加4个0，得到11010110110000，然后用G(X)的位串10011去除，再用11010110110000减去余数位串1110，得到的即为CRC位串11010110111110，将对应多项式称为T(X)，显然，T(X)能被G(X)除尽。这样，一旦接收到的CRC位串不能被同样的G(X)的位串除尽，那么一定有传输错误。   

  　　当使用CRC校验码进行差错控制时，除了为G(X)的整数倍的差错多项式不能被检测外，其它差错均能被查出。CRC校验码的差错控制效果取决于G(X)的阶数，阶数越高，效果越好。目前，常用的有两种生成多项式G(X)的方法，分别是：   

  　　CRC-16　　X16+X15+X2+1   

  　　CCITT　　X16+X12+X5+1   

  　　CRC校验码实际上是一种线性码，将任意CRC校验码循环移位后仍然是一个CRC校验码。由于它有良好的结构，检错能力强，易于实现硬件编、译码，因此在数据通信系统中得到广泛的应用。

 

二。

CRC的全称为Cyclic Redundancy Check，中文名称为循环冗余校验。它是一类重要的线性分组码，编码和解码方法简单，检错和纠错能力强，在通信领域广泛地用于实现差错控制。

实际上，除数据通信外，CRC在其它很多领域也是大有用武之地的。例如我们读软盘上的文件，以及解压一个ZIP文件时，偶尔会碰到“Bad CRC”错误，由此它在数据存储方面的应

用可略见一斑。

差错控制理论是在代数理论基础上建立起来的。这里我们着眼于介绍CRC的算法与实现，对原理只能捎带说明一下。若需要进一步了解线性码、分组码、循环码、纠错编码等方面的原

理，可以阅读有关资料。

利用CRC进行检错的过程可简单描述为：在发送端根据要传送的k位二进制码序列，以一定的规则产生一个校验用的r位监督码(CRC码)，附在原始信息后边，构成一个新的二进制码序

列数共k+r位，然后发送出去。在接收端，根据信息码和CRC码之间所遵循的规则进行检验，以确定传送中是否出错。这个规则，在差错控制理论中称为“生成多项式”。

1 代数学的一般性算法

在代数编码理论中，将一个码组表示为一个多项式，码组中各码元当作多项式的系数。例如 1100101 表示为

1·x6+1·x5+0·x4+0·x3+1·x2+0·x+1，即 x6+x5+x2+1。

设编码前的原始信息多项式为P(x)，P(x)的最高幂次加1等于k；生成多项式为G(x)，G(x)的最高幂次等于r；CRC多项式为R(x)；编码后的带CRC的信息多项式为T(x)。

发送方编码方法：将P(x)乘以xr(即对应的二进制码序列左移r位)，再除以G(x)，所得余式即为R(x)。用公式表示为

T(x)=xrP(x)+R(x)

接收方解码方法：将T(x)除以G(x)，如果余数为0，则说明传输中无错误发生，否则说明传输有误。

举例来说，设信息码为1100，生成多项式为1011，即P(x)=x3+x2，G(x)=x3+x+1，计算CRC的过程为

      xrP(x)     x3(x3+x2)     x6+x5                    x
     -------- = ---------- = -------- = (x3+x2+x) + --------
       G(x)       x3+x+1      x3+x+1                 x3+x+1



即 R(x)=x。注意到G(x)最高幂次r=3，得出CRC为010。

如果用竖式除法，计算过程为

               1110
            -------   
      1011 /1100000     (1100左移3位)
            1011
            ----
             1110
             1011
             -----
              1010
              1011
              -----
               0010
               0000
               ----
                010



因此，T(x)=(x6+x5)+(x)=x6+x5+x, 即 1100000+010=1100010

如果传输无误，

       T(x)     x6+x5+x
      ------ = --------- = x3+x2+x,
       G(x)     x3+x+1



无余式。回头看一下上面的竖式除法，如果被除数是1100010，显然在商第三个1时，就能除尽。

 

 

三。

CRC校验

    crc算法已经有成熟和比较经典的现成代码可供我们利用。CRC计算可以靠专用的硬件来实现,但是对于低成本的微控制器系统,在没有硬件支持下实现CRC检验,关键的问题就是如何通过软件来完成CRC计算,也就是CRC算法的问题。CRC校验的基本思想是利用线性编码理论,在发送端根据要传送的k位二进制码序列,以一定的规则产生一个校验用的监督码（既CRC码）r位,并附在信息后边,构成一个新的二进制码序列数共(k+r)位,最后发送出去。在接收端,则根据信息码和CRC码之间所遵循的规则进行检验,以确定传送中是否出错。

1.生成多项式。

16位的CRC码产生的规则是先将要发送的二进制序列数左移16位（既乘以 

）后,再除以一个多项式,最后所得到的余数既是CRC码。任意一个由二进制位串组成的代码都可以和一个系数仅为‘0’和‘1’取值的多项式一一对应。例如：代码1010111对应的多项式为x6+x4+x2+x+1，而多项式为x5+x3+x2+x+1对应的代码101111。

标准CRC生成多项式如下表：

   名称        生成多项式              简记式*   标准引用 

   CRC-4       x4+x+1                  3         ITU G.704 

   CRC-8       x8+x5+x4+1              0x31                    

   CRC-8       x8+x2+x1+1              0x07                    

   CRC-8       x8+x6+x4+x3+x2+x1       0x5E 

   CRC-12      x12+x11+x3+x+1          80F

   CRC-16      x16+x15+x2+1            8005      IBM SDLC

   CRC16-CCITT x16+x12+x5+1            1021      ISO HDLC, ITU X.25, V.34/V.41/V.42, PPP-FCS 

   CRC-32      x32+x26+x23+...+x2+x+1 04C11DB7 ZIP, RAR, IEEE 802 LAN/FDDI, IEEE 1394, PPP-FCS 

   CRC-32c     x32+x28+x27+...+x8+x6+1 1EDC6F41 SCTP //叶子：这里不知道问什么省略了，有些迷惑哦。要是生成多项式要是都省了，那还怎么校验？我猜想可能是中间的全为一吧。

                              

   生成多项式的最高位固定的1，故在简记式中忽略最高位1了，如0x1021实际是0x11021。

I、基本算法（人工笔算）：

   以CRC16-CCITT为例进行说明，CRC校验码为16位，生成多项式17位。假如数据流为4字节：BYTE[3]、BYTE[2]、BYTE[1]、BYTE[0]；

数据流左移16位，相当于扩大256×256倍，再除以生成多项式0x11021，做不借位的除法运算（相当于按位异或），所得的余数就是CRC校验码。

发送时的数据流为6字节：BYTE[3]、BYTE[2]、BYTE[1]、BYTE[0]、CRC[1]、CRC[0]；

II、计算机算法1（比特型算法）：

1)将扩大后的数据流（6字节）高16位（BYTE[3]、BYTE[2]）放入一个长度为16的寄存器；

2)如果寄存器的首位为1，将寄存器左移1位(寄存器的最低位从下一个字节获得)，再与生成多项式的简记式异或；

    否则仅将寄存器左移1位(寄存器的最低位从下一个字节获得)；

3)重复第2步，直到数据流（6字节）全部移入寄存器；

4)寄存器中的值则为CRC校验码CRC[1]、CRC[0]。

III、计算机算法2（字节型算法）：256^n表示256的n次方

    把按字节排列的数据流表示成数学多项式，设数据流为BYTE[n]BYTE[n－1]BYTE[n－2]、、、BYTE[1]BYTE[0]，表示成数学表达式为BYTE[n]×256^n+BYTE[n-1]×256^(n-1)

+...+BYTE[1]*256+BYTE[0]，在这里+表示为异或运算。设生成多项式为G17（17bit），CRC码为CRC16。

    则，CRC16＝(BYTE[n]×256^n+BYTE[n-1]×256^(n-1)+...+BYTE[1]×256+BYTE[0])×256^2/G17，即数据流左移16位，再除以生成多项式G17。

    先变换BYTE[n-1]、BYTE[n-1]扩大后的形式，

    CRC16＝BYTE[n]×256^n×256^2/G17+BYTE[n-1]×256^(n-1)×256^2/G17+...+BYTE[1]×256×256^2/G17+BYTE[0]×256^2/G17

         ＝(Z[n]+Y[n]/G17)×256^n+BYTE[n-1]×256^(n-1)×256^2/G17+...+BYTE[1]×256×256^2/G17+BYTE[0]×256^2/G17

         ＝Z[n]×256^n+{Y[n]×256/G17+BYTE[n-1]×256^2/G17}×256^(n-1)+...+BYTE[1]×256×256^2/G17+BYTE[0]×256^2/G17

         ＝Z[n]×256^n+{(YH8[n]×256+YHL[n])×256/G17+BYTE[n-1]×256^2/G17}×256^(n-1)+...+BYTE[1]×256×256^2/G17+BYTE[0]×256^2/G17

         ＝Z[n]×256^n+{YHL[n]×256/G17+(YH8[n]+BYTE[n-1])×256^2/G17}×256^(n-1)+...+BYTE[1]×256×256^2/G17+BYTE[0]×256^2/G17

    这样就推导出，BYTE[n-1]字节的CRC校验码为{YHL[n]×256/G17+(YH8[n]+BYTE[n-1])×256^2/G17}，即上一字节CRC校验码Y[n]的高8位（YH8[n]）与本字节BYTE[n-1]异或，

该结果单独计算CRC校验码（即单字节的16位CRC校验码，对单字节可建立表格，预先生成对应的16位CRC校验码），所得的CRC校验码与上一字节CRC校验码Y[n]的低8位（YL8[n]）

乘以256（即左移8位）异或。然后依次逐个字节求出CRC，直到BYTE[0]。

    字节型算法的一般描述为：本字节的CRC码，等于上一字节CRC码的低8位左移8位，与上一字节CRC右移8位同本字节异或后所得的CRC码异或。    

    字节型算法如下：

    1)CRC寄存器组初始化为全"0"(0x0000)。（注意：CRC寄存器组初始化全为1时，最后CRC应取反。）

    2)CRC寄存器组向左移8位,并保存到CRC寄存器组。

    3)原CRC寄存器组高8位（右移8位）与数据字节进行异或运算，得出一个指向值表的索引。

    4)索引所指的表值与CRC寄存器组做异或运算。

    5)数据指针加1，如果数据没有全部处理完，则重复步骤2)。

    6)得出CRC。

unsigned short GetCrc_16(unsigned char * pData, int nLength)

//函数功能：计算数据流* pData的16位CRC校验码，数据流长度为nLength

{

    unsigned short cRc_16 = 0x0000;    // 初始化

    

    while(nLength>0)

    {

        cRc_16 = (cRc_16 << 8) ^ cRctable_16[((cRc_16>>8) ^ *pData) & 0xff]; //cRctable_16表由函数mK_cRctable生成

        nLength--;

        pData++;

    }

    

    return cRc_16;    

}



void mK_cRctable(unsigned short gEnpoly)

//函数功能：生成0－255对应的16CRC校验码，其实就是计算机算法1（比特型算法）

//gEnpoly为生成多项式

//注意，低位先传送时，生成多项式应反转(低位与高位互换)。如CRC16-CCITT为0x1021，反转后为0x8408

{ 

unsigned short cRc_16=0;

unsigned short i,j,k;

for(i=0,k=0;i<256;i++,k++)

{

      cRc_16 = i<<8;

      for(j=8;j>0;j--)

      {

if(cRc_16&0x8000)                 //反转时cRc_16&0x0001

             cRc_16=(cRc_16<<=1)^gEnpoly; //反转时cRc_16=(cRc_16>>=1)^gEnpoly

         else

             cRc_16<<=1;                   //反转时cRc_16>>=1

      }

      cRctable_16[k] = cRc_16;

}

}

2：CRC码集选择的原则

若设码字长度为N，信息字段为K位，校验字段为R位(N=K+R)，则对于CRC码集中的任一码字，存在且仅存在一个R次多项式g(x)，使得

V(x)=A(x)g(x)=xRm(x)+r(x);

其中:    m(x)为K次信息多项式， r(x)为R-1次校验多项式，

         g(x)称为生成多项式：

g(x)=g0+g1x+ g2x2+...+g(R-1)x(R-1)+gRxR

发送方通过指定的g(x)产生CRC码字，接收方则通过该g(x)来验证收到的CRC码字。

3、CRC校验码软件生成方法：

    借助于多项式除法，其余数为校验字段。

例如：信息字段代码为: 1011001；对应m(x)=x6+x4+x3+1

      假设生成多项式为：g(x)=x4+x3+1；则对应g(x)的代码为: 11001

      x4m(x)=x10+x8+x7+x4 对应的代码记为：10110010000；

采用多项式除法: 得余数为: 1010     (即校验字段为：1010）

发送方：发出的传输字段为: 1 0 1 1 0 0 1 1 0 10

计算机数据通信中，由于干扰等各种内外因素，数据出现差错不可避免，在数据通信中需要对数据进行差错检测。实现差错检测的基本原理是：发送方在发送数据的基础上生产某些编码，然后将校验编码附加在数据后面一起发送，接收方在收到数据和校验码之后，用校验码对数据进行校验，确认传输的数据是否正确。差错检测技术的核心是校验编码，常用的校验有奇偶校验，恒比较校验和循环冗余校验编码三种。在此我们主要介绍循环冗余校验编码。

1.奇偶校验：对要发送的格式报文中的数字“1”码元个数统计，采用奇偶校验的时候，通过添加一个码元使的报文中的“1”为奇数（奇校验）或者偶数（偶校验），如果在接收的时候发现报文中的“1”码元数不符合奇偶校验的规定，就判定数据出错。奇偶校验存在一定的缺陷：当出错码元个数为奇数的时候才有效，如果为偶数的话，奇偶校验就不能检测出来。ISO规定，在同步传输系统中，采用奇校验，在异步传输系统中，采用偶校验。

2.恒比码：在通信时不是原码传送，而是对待发送的数据编码，使之编码之后的每一个字节中，“1”与“0”的个数之比保持恒定，称之为恒比码，该编码用于国内电报通信。恒比码纠错能力稍强于奇偶校验，当码组中出现奇数个数的差错时，破坏了“0”与“1”的恒比关系，能够被检测出来，当出现偶数个数的差错时，只要不是非置换型的两个码元错误，即两数个“0”全错成“1”，或者相反，都可以检测出来，但是出现置换型的错误，即某个位置的“1”出错为“0”，而另外一个位置的“0”出错为“1”，恒比码则不能检测出来。

3.循环冗余校验码：简称CRC码，CRC校验码是一种高性能的检错码，具有检错能力强，实现简单容易，良好的代数结构等特点，比如奇偶校验和恒比码不能检测出来的置换型错误，CRC校验能够很好的检测出来。

线性码和循环码：有k个信息码元与r个校验码元构成的线性码组，其中每一个校验码元是该码组中某些信息码元的模2除运算（每个数据位，与除数做逻辑异或运算），具有该结构格式的码组为线性码。对于线性码如其具有如下性质：任一码组的每一次循环右移或者左移，所得到的新码组仍然是该码中的一码组，我们将具有这种循环移位不变性的线性码称之为循环码。

为便于用代数研究循环码，将码组中的各个码元当做一个多项式的系数，即码组C=(Cn-1,Cn-2,Cn-3....C1,C0,)所对应的多项式表达为C(X)=C(X)=Cn-1＋Cn-２＋．．．＋C1＋C０

 

CRC-16 　g(X)=＋＋＋1

CRC-CITT g(X)=＋＋＋1

上面三个多项式已经成为国际标准，其中，CRC-12用于6位字符同步系统，能检测出长度在12为以内的突发差错，CRC-16和CRC-CITT用于8位字符同步系统，能够检测出全部的1位，2位和奇数位的差错，所有长度不大于16位的突发错，以及99.997%的位突发错和99.998%的18位或更多位的突发错。

CRC循环码编程：(查表法，C#语言代码，CRC-16循环码，其中CRC_LEN=0）

C#语言代码：

public static byte[] CRC16(byte[] data)///CRC16校验码生成，传入字节数组，返回字节数组
　{
　　byte[] outdata = new byte[2];
#region CRC16码表
byte[] auchCRCHi = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
};
byte[] auchCRCLow = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26, 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C, 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40
};
#endregion
　　byte crcHi = 0xff;
　　byte crcLow = 0xff;
　　for (int i = 0; i < data.Length - CRC_LEN; i++)
　　　{

　　　　int crcIndex = crcHi ^ data[i];
　　　　crcHi = (byte)(crcLow ^ auchCRCHi[crcIndex]);
　　　　crcLow = auchCRCLow[crcIndex];
　　　　}
　　　outdata[0] = crcHi;
　　　outdata[1] = crcLow;
　　　return (outdata);
}

 

 

来自 http://blog.chinaunix.net/uid-22002627-id-3015101.html
CRC校验采用多项式编码方法，如一个8位二进制数(B7B6B5B4B3B2B1B0)可以用7阶二进制码多项式B7X7+B6X6+B5X5+B4X4+B3X3+B2X2+B1X1+B0X0表示。 
　　例如11000001可表示为 
　　1X7+1X6+0X5+0X4+0X3+0X2+0X1+0X0 
　　一般说，n位二进制数可用(n-1)阶多项式表示。它把要发送的数据位串看成是系数只能为“1”或“0”的多项式。一个n位的数据块可以看成是从Xn-1到X0的n项多项式的系数序列，位于数据块左边的最高位是Xn-1项的系数，次高位是Xn-2项的系数，依此类推，位于数据块右边的最低位是X0项的系数，这个多项式的阶数为n-1。 
　　多项式乘除法运算过程与普通代数多项式的乘除法相同。多项式的加减法运算以2为模，加减时不进、错位，如同逻辑异或运算。 
　　采用CRC校验时，发送方和接收方事先约定一个生成多项式G(X)，并且G(X)的最高项和最低项的系数必须为1。设m位数据块的多项式为M(X)，生成多项式G(X)的阶数必需比M(X)的阶数低。CRC校验码的检错原理是：发送方先为数据块生成CRC校验码，使这个CRC校验码的多项式能被G(X)除尽，实际发送此CRC校验码；接收方用收到的CRC校验码除以G(X)，如果能除尽，表明传输正确，否则，表示有传输错误，请求重发。 
　　生成数据块的CRC校验码的方法是： 
　　(1)   设G(X)为r阶，在数据块末尾添加r个0，使数据块为m+r位，则相应的多项式为XrM(X)； 
　　(2)   以2为模，用对应于G(X)的位串去除对应于XrM(X)的位串，求得余数位串； 
　　(3)   以2为模，从对应于XrM(X)的位串中减去余数位串，结果就是为数据块生成的带足够校验信息的CRC校验码位串。 
　　例如，设要发送的数据为1101011011，G(X)=X4+X+1，则首先在发送数据块的末尾加4个0，得到11010110110000，然后用G(X)的位串10011去除，再用11010110110000减去余数位串1110，得到的即为CRC位串11010110111110，将对应多项式称为T(X)，显然，T(X)能被G(X)除尽。这样，一旦接收到的CRC位串不能被同样的G(X)的位串除尽，那么一定有传输错误。 
　　当使用CRC校验码进行差错控制时，除了为G(X)的整数倍的差错多项式不能被检测外，其它差错均能被查出。CRC校验码的差错控制效果取决于G(X)的阶数，阶数越高，效果越好。目前，常用的有两种生成多项式G(X)的方法，分别是： 
　　CRC-16　　X16+X15+X2+1 
　　CCITT　　X16+X12+X5+1 
　　CRC校验码实际上是一种线性码，将任意CRC校验码循环移位后仍然是一个CRC校验码。由于它有良好的结构，检错能力强，易于实现硬件编、译码，因此在数据通信系统中得到广泛的应用。