crc16校验原理

校验原理

1、循环校验码（CRC 码）：是数据通信领域中最常用的一种差错校验码，其特征

是信息字段和校验字段的长度可以任意选定。

2、生成CRC 码的基本原理：任意一个由二进制位串组成的代码都可以和一个系数仅为‘0’和‘1’取值的多项式一一对应。例如：代码1010111 对应的多项式为

x6+x4+x2+x+1，而多项式为x5+x3+x2+x+1 对应的代码101111。3、CRC 码集选择的原则：若设码字长度为N，信息字段为K 位，校验字段为R 位(N=K+R)，则对于CRC 码集中的任一码字，存在且仅存在一个R 次多项式g(x)，使得

V(x)=A(x)g(x)=x R m(x)+r(x);

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

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

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

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

CRC 码字。

4、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

信息字段校验字段

接收方：使用相同的生成码进行校验:接收到的字段/生成码（二进制除法）如果能够除尽，则正确，

CRC校验源码分析

这两天做项目，需要用到CRC校验。以前没搞过这东东，以为挺简单的。结果看看别人提供的汇编源程序，居然看不懂。花了两天时间研究了一下CRC校验，希望我写的这点东西能够帮助和我有同样困惑的朋友节省点时间。

先是在网上下了一堆乱七八遭的资料下来，感觉都是一个模样，全都是从CRC 的数学原理开始，一长串的表达式看的我头晕。第一次接触还真难以理解。这些东西不想在这里讲，随便找一下都是一大把。我想根据源代码来分析会比较好懂一些。

费了老大功夫，才搞清楚CRC根据”权”(即多项表达式)的不同而相应的源代码也有稍许不同。以下是各种常用的权。

CRC8=X8+X5+X4+1

CRC-CCITT=X16+X12+X5+1

CRC16=X16+X15+X5+1

CRC12=X12+X11+X3+X2+1

CRC32=X32+X26+X23+X22+X16+X12+X11+X10+X8+X7+X5+X4+X2+X1 +1

以下的源程序全部以CCITT为例。其实本质都是一样，搞明白一种，其他的都是小菜。

图1，图2说明了CRC校验中CRC值是如何计算出来的，体现的多项式正是X16+X12+X5+1。Serial Data即是需要校验的数据。从把数据移位开始计算，将数据位（从最低的数据位开始）逐位移入反向耦合移位寄存器(这个名词我也不懂，觉得蛮酷的，就这样写了，嘿)。当所有数据位都这样操作后，计算结束。此时，16位移位寄存器中的内容就是CRC码。

图中进行XOR运算的位与多项式的表达相对应。

X5代表Bit5，X12代表Bit12，1自然是代表Bit0，X16比较特别，是指移位寄存器移出的数据，即图中的DATA OUT。可以这样理解，与数据位做XOR 运算的是上次CRC值的Bit15。

根据以上说明，可以依葫芦画瓢的写出以下程序。(程序都是在keil C 7.10下调试的)

typedef unsigned char uchar;

typedef unsigned int uint;

code uchar crcbuff [] = { 0x00,0x00,0x00,0x00,0x06,0x0d,0xd2,0xe3};

uint crc; // CRC码

void main(void)

{

uchar *ptr;

crc = 0; // CRC初值

ptr = crcbuff; //指向第一个Byte数据

crc = crc16l(ptr,8);

while(1);

}

uint crc16l(uchar *ptr,uchar len) // ptr为数据指针，len为数据长度{

uchar i;

while(len--)

{

for(i=0x80; i!=0; i>>=1)

{

if((crc&0x8000)!=0) {crc<<=1; crc^=0x1021;} else crc<<=1;

if((*ptr&i)!=0) crc^=0x1021; 1-1 1-2 1-3

}

ptr++;

}

return(crc);

}

执行结果crc = 0xdbc0;

程序1-1,1-2,1-3可以理解成移位前crc的Bit15与数据对应的

Bit(*ptr&i) 做XOR运算，根据此结果来决定是否执行crc^=0x1021。只要明白两次异或运算与原值相同，就不难理解这个程序。

很多资料上都写了查表法来计算，当时是怎么也没想通。其实蛮简单的。假设通过移位处理了8个bit的数据，相当于把之前的CRC码的高字节(8bit)全部移出，与一个byte的数据做XOR运算，根据运算结果来选择一个值(称为余式)，与原来的CRC码再做一次XOR运算，就可以得到新的CRC码。

不难看出，余式有256种可能的值，实际上就是0~255以

X16+X12+X5+1 为权得到的CRC码，可以通过函数crc16l来计算。以1为

例。

code test[]={0x01};

crc = 0;

ptr = test;

crc = crc16l(ptr,1);

执行结果crc = 1021，这就是1对应的余式。

进一步修改函数，我这里就懒得写了，可得到X16+X12+X5+1的余式表。

code uint crc_ta[256]={ // X16+X12+X5+1 余式表

0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,

0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,

0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,

0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,

0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,

0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,

0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,

0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,

0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,

0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,

0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 0x1080,

0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x02b1,

0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 0x34e2,

0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c, 0x26d3,

0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 0x5844,

0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3, 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75,

0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,

0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,

0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0

};

根据这个思路，可以写出以下程序：

uint

table_crc(uchar

*ptr,uchar len) //

字节查表法求

CRC {

uchar da;

while(len--!=0) {

da=(uchar)

(crc/256); // 以 8 位二进制数暂存 CRC 的高 8 位 crc<<=8;

// 左移 8 位 crc^=crc_ta[da^*ptr]; // 高字节和当前数据 XOR 再查表 ptr++;

} return(crc); } 本质上 CRC 计算的就是移位和异或。所以一次处理移动几位都没有关系，只要做相应的处理就好了。

下面给出半字节查表的处理程序。其实和全字节是一回事。 code uint crc_ba[16]={

};

0x8108, 0x9129, 0xa14a, 0xb16b, 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, uint ban_crc(uchar *ptr,uchar len) {

uchar da; while(len--!=0) {

da = ((uchar)(crc/256))/16; crc <<= 4;

crc ^=crc_ba[da^(*ptr/16)]; da = ((uchar)(crc/256)/16); crc <<= 4;

crc ^=crc_ba[da^(*ptr&0x0f)]; ptr++; }

return(crc); }

crc_ba[16]和 crc_ta[256]的前 16 个余式是一样的。

其实讲到这里，就已经差不多了。反正当时我以为自己是懂了。结果去看别人的

源代码的时候，也是说采用CCITT，但是是反相的。如图 3

反过来，一切都那么陌生，faint.吐血，吐血。

仔细分析一下，也可以很容易写出按位异或的程序。只不过由左移变成右移。

uint crc16r(unsigned char *ptr, unsigned char len)

{

unsigned char i;

while(len--!=0)

{

for(i=0x01;i!=0;i <<= 1)

{

if((crc&0x0001)!=0) {crc >>= 1; crc ^= 0x8408;}

else crc >>= 1;

if((

*ptr&i)!=

0) crc ^=

0x8408; }

ptr++; }

return(crc

);

}

0x8408就是CCITT的反转多项

式。套用别人资料上的话

“反转多项式是指在数据通讯时，信息字节先传送或接收低位字节，如重新排位影响CRC计算速度，故设反转多项式。”

如

code uchar crcbuff [] = { 0x00,0x00,0x00,0x00,0x06,0x0d,0xd2,0xe3};

反过来就是

code uchar crcbuff_fan[] = {0xe3,0xd2,0x0d,0x06,0x00,0x00,0x00,0x00};

crc = 0;

ptr = crcbuff_fan;

crc = crc16r(ptr,8);

执行结果crc = 0x5f1d;

如想验证是否正确，可改

code uchar crcbuff_fan_result[] =

{0xe3,0xd2,0x0d,0x06,0x00,0x00,0x00,0x00,0x1d,0x5f};

ptr = crcbuff_fan_result;

crc = crc16r(ptr,10);

执行结果crc = 0;符合CRC校验的原理。

请注意0x5f1d在数组中的排列中低位在前，正是反相运算的特点。不过当时是把我搞的晕头转向。

在用半字节查表法进行反相运算要特别注意一点，因为是右移，所以CRC移出的4Bit与数据XOR的操作是在CRC的高位端。因此余式表的产生是要以下列数组通过修改函数crc16r产生。

code uchar ban_fan[]=

{0,0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x80,0x90,0xa0,0xb0,0xc0,0xd0,0xe 0,0xf0};

得出余式表

code uint fan_yushi[16]={

0x0000, 0x1081, 0x2102,

0x3183, 0x4204, 0x5285, 0x6306,

0x7387, 0x8408, 0x9489, 0xa50a,

0xb58b, 0xc60c, 0xd68d, 0xe70e,

0xf78f

};

uint ban_fan_crc(uchar *ptr,uchar len)

{

uchar da;

while(len--!=0)

{

da = (uchar)(crc&0x000f);

crc >>= 4;

crc ^= fan_yushi [da^(*ptr&0x0f)];

da = (uchar)(crc&0x000f);

crc >>= 4;

crc ^= fan_yushi [da^(*ptr/16)];

ptr++;

}

return(crc);

}

主程序中

crc = 0;

ptr = crcbuff_fan;

crc = ban_fan_crc(ptr,8);

执行结果crc =

反相运算的算法简单实现crc 校验

0x5f1d;

前一段时间做协议转换器的时间用到CRC-16 校验，查了不少资料发现都不理想。查表法要建表太麻烦，而计算法觉得那些例子太罗嗦。最后只好自己写了，最后发现原来挺简单嘛：）

两个子程序搞定。这里用的多项式为：

CRC-16 = X16 + X12 + X5 + X0 =

2^0+2^5+2^12+2^16=0x11021

因最高位一定为“1”，故略去计算只采用0x1021 即可

CRC_Byte：计算单字节的CRC 值

CRC_Data：计算一帧数据的CRC 值

CRC_High CRC_Low：存放单字节CRC

值CRC16_High CRC16_Low：存放帧数据

CRC 值

;<>------------------------------------------------------------

; Function: CRC one byte

; Input: CRCByte

; Output: CRC_High CRC_Low

;<>------------------------------------------------------------

CRC_Byte:

clrf CRC_Low

clrf CRC_High

movlw 09H

movwf v_Loop1

movf CRCByte, w

movwf CRC_High

CRC:

decfsz v_Loop1 ；8 次循环，每一位相应计算

goto CRC10

goto CRCend

CRC10

bcf STATUS, C

rlf CRC_Low

rlf CRC_High

btfss STATUS, C

goto CRC ；为0 不需计算

movlw 10H ;若多项式改变，这里作相应变化

xorwf CRC_High, f

movlw 21H ;若多项式改变，这里作相应变化

xorwf CRC_Low, f

goto CRC

CRCend:

nop

return

;<>------------------------------------------------------------

; CRC one byte end

;<>------------------------------------------------------------

; Function: CRC date

; Input: BufStart(A,B,C)（一帧数据的起始地

址）v_Count （要做CRC 的字节数）

; Output: CRC16_High CRC16_Low（结果）

;<>------------------------------------------------------------

CRC_Data:

clrf CRC16_High

clrf CRC16_Low

CRC_Data10

movf INDF, w

xorwf CRC16_High,w

movwf CRCByte

call CRC_Byte

incf FSR

decf v_Count ;需计算的字节数

movf CRC_High, w

xorwf CRC16_Low, w

movwf CRC16_High

movf CRC_Low, w

movwf CRC16_Low

movf v_Count, w

；计算结束？

btfss STATUS, Z

goto CRC_Data10

return

;<>------------------------------------------------------------ ;

CRC date end

;<>------------------------------------------------------------

说明： CRC 的计算原理如下（一个字节的简单例子） 11011000 00000000 00000000 ^10001000 00010000

1 1010000 00010000 10

<- 一个字节数据, 左移 16b <- CRC-CCITT 多项式, 17b <- 中间余数

^1000100 00001000 01

10100

00011000 1100 ^10001 00000010 0001

101 00011010

110100 ^100 01000000 100001

1 01011010

01010100 ^1

00010000 00100001

01001010 01110101 仿此，可推出两个字节数据计算如下：d 为数据，p 为项式，a 为余数 dddddddd dddddddd 00000000 00000000 <- 数据 D ( D1, D0, 0, ^pppppppp pppppppp p

<- 16b CRC 0 ) <- 多项式 P aaaaaaaa aaaaaaaa 0

<- 第一次的余数 A ’ ( A ’1, A ’

0 )

^pppppppp pppppppp p

aaaaaaaa aaaaaaaa <- 结果 A ( A1, A0 ) 由此与

一字节的情况比较，将两个字节分开计算如下：

先算高字节：

dddddddd 00000000 00000000 00000000 <- D1, 0, 0, 0 ^pppppppp pppppppp p <- P

aaaaaaaa aaaaaaaa

1 = PHA1 ^ D0, A’0 =

PHA0：

aaaaaaaa aaaaaaaa

^dddddddd

aaaaaaaa aaaaaaaa

低字节的计算：

aaaaaaaa 00000000 00000000 ^pppppppp pppppppp p 此

处

的

部

分

余

数

与

前

面

两

字

节

算

法

中

的

第

一

次

余

数

有

如

下

关

系

，

即

A’

<- 高字节

部分余数

PHA1,

PHA0

PHA1,

PHA0 D0

A’1, A’0

A’1, 0, 0

aaaaaaaa

aaaaaaaa ^aaaaaaaa aaaaaaaa aaaaaaaa <

低字节部分余数PLA1,

PLA0 A’0 ，即

PHA0

最后的CRC ( A1,

A0 )

总结以上内容可得规律如下：

设部分余数函数

PA = f( d )

其中 d 为一个字节的数据（注意，除非n = 0 ，否则就不是原始数据，见下文）

第n 次的部分余数

PA( n ) = ( PA( n - 1 ) <<

8 ) ^ f( d ) 其中的

d = ( PA( n - 1 ) >> 8 )

^ D( n ) 其中的D( n ) 才是一个

字节的原始数据。

公式如下：

PA( n ) = ( PA( n - 1 ) << 8 ) ^ f( ( PA( n - 1 ) >> 8 ) ^ D

)

可以注意到函数f( d ) 的参数 d 为一个字节，对一个确定的多项式P，f( d ) 的返回值是与 d 一一对应的，总数为256 项，将这些数据预先算出保存在表里，f( d )就转换为一个查表的过程，速度也就可以大幅提高，这也就是查表法计算CRC 的原理。

再来看CRC 表是如何计算出来的，即函数f( d ) 的实现方法。分析前面一个字节数据的计算过程可发现，d 对结果的影响只表现为对P 的移位异或，看计算过程中的三个8 位的列中只低两个字节的最后结果是余数，而数据所在的高8 位列最后都被消去了，因其中的运算均为异或，不产生进位或借位，故每一位数据只影响本列的结果，即 d 并不直接影响结果。再将前例变化一下重列如下：

11011000

^ ^ ^ ^ ^ ^ 10001000

00010000 1 ^ 1000100 00001000 01

000000 00000000 000 10001 00000010 0001 0000 00000000 00000 100 01000000 100001 00 00000000 0000000 1 00010000 00100001 // P //

P // P // 0 // P // 0 // P // 0

01001010 01110101

现在的问题就是如何根据 d 来对P 移位异或了，从上面的例子看，也可以理解为每步移位，但根据 d 决定中间余数是否与P 异或。从前面原来的例子可以看出，决定的条件是中间余数的最高位为0，因为P 的最高位一定为1，即当中间余数与 d 相应位异或的最高位为1 时，中间余数移位就要和P 异或，否则只需移位即可。其方法如下例（上例的变形，注意其中空格的移动表现了d 的影响如何被排除在结果之外）：

d --------a-------

1 00000000 00000000 <- HSB =

0000000 000000000 <- a

<<= 1 0001000 000100001 <-不含最

高位的 1

1 0001000 000100001

001000

0001000010

000100

0 001100 0001100011 < HSB =0

0000100001

01100 00011000110

1 01100 00011000110 < HSB =1

1100

000110001100

0001

1 1101 000110101101 < HSB =0

000000100001

101 0001101011010

0 101 0001101011010 < HSB =1

00011010110100

0 01 01011010010101 < HSB =0

01000000100001

1 010110100101010

0 1 010110100101010 < HSB =1

010110100101010

000100000010000

1 0100101001110101

结合这些，前面的程序就好理解了。

循环冗余校验码

CRC（Cyclic Redundancy Check)循环冗余校验码

是常用的校验码，在早期的通信中运用广泛，因为早期的通信技术不够可靠（不可靠性的来源是通信技术决定的，比如电磁波通信时受雷电等因素的影响），不可靠的通信就会带来‘确认信息’的困惑，书上提到红军和蓝军通信联合进攻山下的敌军的例子，第一天红军发了条信息要蓝军第二天一起进攻，蓝军收到之后，发一条确认信息，但是蓝军担心的是‘确认信息’如果也不可靠而没有成功到达红军那里，那自己不

是很危险？于是红军再发一条‘对确认的确认信息’，但同样的问题还是不能解决，红军仍然不敢贸然行动。

对通信的可靠性检查就需要‘校验’，校验是从数据本身进行检查，它依靠某种数学上约定的形式进行检查，校验的结果是可靠或不可靠，如果可靠就对数据进行处理，如果不可靠，就丢弃重发或者进行修复。

CRC 码是由两部分组成，前部分是信息码，就是需要校验的信息，后部分是校验码，如果CRC 码共长n 个bit ，信息码长k 个bit，就称为(n,k)码。它的编码规则是：

1、首先将原信息码(kbit)左移r 位(k+r=n)

2、运用一个生成多项式g(x) （也可看成二进制数）用模2 除上面的式子，得到的余数就是校验码。

非常简单，要说明的：模2 除就是在除的过程中用模2 加，模2 加实际上就是

我们熟悉的异或运算，就是加法不考虑进位，公式是：

0+0=1+1=0,1+0=0+1=1

即‘异’则真，‘非异’则假。

由此得到定理：a+b+b=a 也就是‘模2 减’和‘模2 加’直值表完全相同。有了加减法就可以用来定义模2 除法，于是就可以用生成多项式g(x)生成CRC

校验码。

例如：g(x)=x4+x3+x2+1,(7,3)码,信息码110 产生的CRC 码就是：对于

g(x)=x4+x3+x2+1 的解释：（都是从右往左数）x4 就是第五位是1，因为

没有x1 所以第2 位就是0。

11101 | 110,0000（设a=11101 ，b=1100000 ）

取b 的前5 位11000 跟a 异或得到101 101 加

上b 没有取到的00 得到10100 然后跟a 异或得

到01001

也就是余数1001

余数是1001 ，所以CRC 码是110,1001

标准的CRC 码是，CRC-CCITT 和CRC-16 ，它们的生成多项式是：

CRC-CCITT=x^16+x^12+x^5+1

CRC-16=x^16+x^15+x^2+1

CRC校验原理及其在通信系统中的作用

在通信系统的数据传输过程中，由于信道中各种复杂因素的影响，往往使传输的信号受到干扰，造成误码的出

现。接收方为了检查所接收的数据是否有误码，可采用多种检测方法。差错控制编码是目前数据传输过程中普遍采用的一种提高数据通信可靠性的方法，而CRC是一种在实际通信中应用很广泛的差错控制编码，具有很

强的检错能力。

CRC校验将输入比特（）表示为下列多项式的系数：

式中，D可以看成一个时延因子，表示相应的比特所处的位置。校

验比特（）可由下式求得：

式中，表示取余数,是生成多项式。式中的除法与普通的多项式长除法相同，其差别是系数是二进制，其运算以模2为基础。常用的几个L阶CRC生成多项式为：

其中，和产生的校验比特为16比特，产生的校验比特为32比特。

在实际数据传输过程中，发送方将CRC校验码附加在所传数据流的尾部一并传送；接收方用同样的生成多项式去除接收到的数据流，若余数为零，则可判断所接收到的数据是正确的。否则，可判断数据在传输过程中产生了误码。

2 CRC校验的C语言实现

下面我们以CRC-16为例来说明任意长度数据流的CRC校验码生成过程。我们采用将数据流分成若干个8bit 字符，并由低字节到高字节传送的并行方法来求CRC校验码。具体计算过程为：用一个16bit的寄存器来存放CRC校验值，且设定其初值为0x0000；将数据流的第一个8bit与16bit的CRC寄存器的高字节相异或，并将结果存入CRC寄存器高字节；CRC寄存器左移一位，最低1bit补零，同时检查移出的最高1bit，若移出的最高1bit为0，则继续按上述过程左移，若最高1bit为1，则将CRC寄存器中的值与生成多项式码相异或，结果存入CRC寄存器值；继续左移并重复上述处理方法，直到将8bit数据处理完为止，则此时CRC寄存器中的值就是第一个8bit数据对应的CRC校验码；然后将此时CRC寄存器的值作为初值，用同样的处理方法重复上述步骤来处理下一个8bit数据流，直到将所有的8bit字符都处理完后，此刻CRC寄存器中的值

即为整个数据流对应的CRC校验码。

下面示出了其计算过程的流程图：

在用C语言编写CRC校验码的实现程序时我们应该注意，生成多项式对应的十六进制数为0x18005，由于CRC寄存器左移过程中，移出的最高位为1时与相异或，所以与16bit的CRC寄存器对应的生成多项式的十六进制数可用0x8005表示。下面给出并行处理8bit数据流的Ｃ源程序：

unsigned short crc_dsp(unsigned short reg, unsigned char data_crc)

//reg为crc寄存器，data_crc为将要处理的8bit数据流{

unsigned short msb; //crc寄存器将移出的最高1bit

unsigned short data;

unsigned short gx = 0x8005, i = 0; //i为左移次数，gx为生成多项式

data = (unsigned short)data_crc;

data = data << 8;

reg = reg ^ data;

do {

msb = reg & 0x8000; reg = reg << 1; if(msb == 0x8000) { reg = reg ^ gx; } i++; } while(i < 8); return (reg); }

以上为处理每一个 8bit 数据流的子程序，在计算整个数据流的 CRC 校验码时，我们只需将 CRC_reg 的初值置为 0x0000，求第一个 8bit 的 CRC 值，之后，即可将上次求得的 CRC 值和本次将要处理的 8bit 数据作为函数实参传递给上述子程序的形参进行处理即可，最终返回的 reg 值便是我们所想得到的整个数据流的 CRC 校验值。 3 结论

本文根据 CRC 校验的基本原理，提出了一种并行计算任意长度 CRC 校验值的算法，并给出了源程序，且该源程序可作为一子函数来直接被调用，可灵活的应用在不同的工程当中。此算法已应用与某系统当中，实践证明，该算法正确可靠。

其实 CRC 可以用查表的方法。 /*

CRC 校验算法实现 C 语言代码实现文件 CRC16.h */

#ifndef _CRC16_h

#define _CRC16_h static unsigned char 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, 0x81, 0x40, 0x00, 0xC1, 0x00, 0xC1, 0x81, 0x40, 0x80, 0x41, 0x00, 0xC1, 0x01, 0xC0, 0x80, 0x41, 0x81, 0x40, 0x01, 0xC0, 0x00, 0xC1, 0x81, 0x40, 0x80, 0x41, 0x00, 0xC1, 0x01, 0xC0, 0x80, 0x41, 0x80, 0x41, 0x01, 0xC0, 0x00, 0xC1, 0x81, 0x40, 0x80, 0x41, 0x00, 0xC1, 0x00, 0xC1, 0x81, 0x40, 0x80, 0x41, 0x00, 0xC1, 0x01, 0xC0, 0x80, 0x41, 0x80, 0x41, 0x00, 0xC1, 0x01, 0xC0, 0x80, 0x41, 0x81, 0x40, 0x00, 0xC1, 0x00, 0xC1, 0x81, 0x40, 0x80, 0x41, 0x00, 0xC1,

/* CRC 低位字节值表*/ static char auchCRCLo[] = { 0x00, 0xC0, 0xC1, 0x01, 0x07, 0xC7, 0x05, 0xC5, 0x0F, 0xCF, 0xCE, 0x0E, 0x08, 0xC8, 0xD8, 0x18, 0x1E, 0xDE, 0xDF, 0x1F, 0xD5, 0x15, 0xD7, 0x17, 0x11, 0xD1, 0xD0, 0x10, 0xF2, 0x32, 0x36, 0xF6, 0x3C, 0xFC, 0xFD, 0x3D, 0x3B, 0xFB, 0x39, 0xF9, 0xEB, 0x2B, 0x2A, 0xEA, 0xEC, 0x2C, 0xE4, 0x24, 0x22, 0xE2, 0xE3, 0x23, 0x61, 0xA1, 0x63, 0xA3, 0xA5, 0x65, 0x64, 0xA4, 0x6E, 0xAE, 0xAA, 0x6A, 0x78, 0xB8, 0xB9, 0x79, 0x7F, 0xBF, 0x7D, 0xBD, 0x77, 0xB7, 0xB6, 0x76, 0x70, 0xB0, 0x50, 0x90, 0x96, 0x56, 0x57, 0x97, 0x01,

0x81,

0x01,

0x81,

0x01,

0x80,

0x01,

0x81,

0x00,

0x80,

0x01,

0x81,

0x00,

0x81,

0x00,

0x81,

0x01,

0x81,

0x01,

0x81,

0xC3,

0xC4,

0x0A,

0x19,

0xDD,

0x16,

0xF0,

0xF7,

0xFF,

0xF8,

0xEE,

0x25,

0xE1,

0xA2,

0x6C,

0x6B,

0xBB,

0xBC,

0x72,

0x91,

0x55,

0xC0,

0x40,

0xC0,

0x40,

0xC0,

0x41,

0xC0,

0x40,

0xC1,

0x41,

0xC0,

0x40,

0xC1,

0x40,

0xC1,

0x40,

0xC0,

0x40,

0xC0,

0x40

0x03,

0x04,

0xCA,

0xD9,

0x1D,

0xD6,

0x30,

0x37,

0x3F,

0x38,

0x2E,

0xE5,

0x21,

0x62,

0xAC,

0xAB,

0x7B,

0x7C,

0xB2,

0x51,

0x95,

0x80,

0x01,

0x80,

0x00,

0x80,

0x00,

0x80,

0x00,

0x81,

0x00,

0x80,

0x01,

0x81,

0x01,

0x81,

0x00,

0x80,

0x01,

0x80,

0x02,

0xC

0xCB,

0x1B,

0x1C,

0xD2,

0x31,

0xF5,

0x3E,

0x28,

0x2F,

0x27,

0x20,

0x66,

0xAD,

0x69,

0x7A,

0xB4,

0xB3,

0x93,

0x94,

0x41,

0xC0,

0x41,

0xC1,

0x41,

0xC1,

0x41,

0xC1,

0x40,

0xC1,

0x41,

0xC0,

0x40,

0xC0,

0x40,

0xC1,

0x41,

0xC0,

0x41,

0xC2,

0x0C,

0x0B,

0xDB,

0xD

0x12,

0xF1,

0x35,

0xFE,

0xE8,

0xEF,

0xE7,

0xE0,

0xA6,

0x6D,

0xA9,

0xBA,

0x74,

0x73,

0x53,

0x54,

0x00,

0x80,

0x01,

0x81,

0x00,

0x81,

0x01,

0x81,

0x01,

0x81,

0x01,

0x80,

0x01,

0x80,

0x01,

0x81,

0x00,

0x80,

0x01,

0xC6,

0x0D,

0xC9,

0xDA,

0x14,

0x13,

0x33,

0x34,

0xFA,

0xE9,

0x2D,

0xE6,

0xA0,

0xA7,

0xAF,

0xA8,

0xBE,

0x75,

0xB1,

0x52,

0x9C

0xC1,

0x41,

0xC0,

0x40,

0xC1,

0x40,

0xC0,

0x40,

0xC0,

0x40,

0xC0,

0x41,

0xC0,

0x41,

0xC0,

0x40,

0xC1,

0x41,

0xC0

0x06,

0xC

0x09,

0x1A,

0xD4,

0xD3,

0xF3,

0xF4,

0x3A,

0x29,

0xED,

0x26,

0x60,

0x67,

0x6F,

0x68,

0x7E,

0xB5,

0x71,

0x92,

0x5C

CRC校验码原理

CRC校验码 CRC即循环冗余校验码（Cyclic Redundancy Check）：是数据通信领域中最常用的一种差错校验码，其特征是信息字段和校验字段的长度可以任意选定。目录详细介绍代数学的一般性运算详细介绍循环冗余校验码（CRC）的基本原理是：在K位信息码后再拼接R位的校验码，整个编码长度为N位，因此，这种编码又叫（N，K）码。对于一个给定的（N，K）码，可以证明存在一个最高次幂为N-K=R的多项式G(x)。根据G(x)可以生成K位信息的校验码，而G(x)叫做这个CRC码的生成多项式。校验码的具体生成过程为：假设发送信息用信息多项式C(X)表示，将C(x)左移R位，则可表示成C(x)*2的R次方，这样C(x)的右边就会空出R位，这就是校验码的位置。通过C(x)*2的R次方除以生成多项式G(x)得到的余数就是校验码。几个基本概念 1、多项式与二进制数码多项式和二进制数有直接对应关系：x的最高幂次对应二进制数的最高位，以下各位对应多项式的各幂次，有此幂次项对应1，无此幂次项对应0。可以看出：x的最高幂次为R，转换成对应的二进制数有R+1位。多项式包括生成多项式G(x)和信息多项式C(x)。如生成多项式为G(x)=x4+x3+x+1，可转换为二进制数码11011。而发送信息位1111，可转换为数据多项式为C(x)=x3+x2+x+1。 2、生成多项式是接受方和发送方的一个约定，也就是一个二进制数，在整个传输过程中，这个数始终保持不变。在发送方,利用生成多项式对信息多项式做模2除生成校验码。在接受方利用生成多项式对收到的编码多项式做模2除检测和确定错误位置。应满足以下条件： a、生成多项式的最高位和最低位必须为1。 b、当被传送信息（CRC码）任何一位发生错误时，被生成多项式做除后应该使余数不为0。 c、不同位发生错误时，应该使余数不同。 d、对余数继续做除，应使余数循环。

CRC16校验程序

CRC16校验程序 -------------------------------------------------------------------------------- 作者：转载 //CRC16校验在通讯中应用广泛，这里不对其理论进行讨论，只对常见的3种 //实现方法进行测试。方法1选用了一种常见的查表方法,类似的还有512字 //节、256字等查找表的，至于查找表的生成,这里也略过。 // ---------------- POPULAR POLYNOMIALS ---------------- // CCITT:x^16 + x^12 + x^5 + x^0 (0x1021) // CRC-16: x^16 + x^15 + x^2 + x^0 (0x8005) #define CRC_16_POLYNOMIALS 0x8005 // -------------------------------------------------------------- // CRC16计算方法1:使用2个256长度的校验表 // -------------------------------------------------------------- const BYTE chCRCHTalbe[] = // CRC 高位字节值表{ 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 }; const BYTE chCRCLTalbe[] = // CRC 低位字节值表{ 0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7,

CRC校验实验报告

实验三CRC校验一、CRC校验码的基本原理编码过程： CRC校验码的编码方法是用待发送的二进制数据t(x)除以生成多项式g(x)，将最后的余数作为CRC校验码。其实现步骤如下： 1 设待发送的数据块是m位的二进制多项式t(x)，生成多项式为r阶的g(x)。在数据块的末尾添加r个0，数据块的长度增加到m+r位。 2 用生成多项式g（x）去除，求得余数为阶数为r-1

的二进制多项式y(x)。此二进制多项式y(x)就是t(x)经过生成多项式 g(x)编码的CRC校验码。 3 将y(x)的尾部加上校验码，得到二进制多项式。就是包含了CRC校验码的待发送字符串。解码过程：从CRC的编码规则可以看出，CRC编码实际上是将代发送的m位二进制多项式t(x)转换成了可以被g(x)除尽的m+r位二进制多项式所以解码时可以用接收到的数据去除g（x），如果余数位零，则

表示传输过程没有错误；如果余数不为零，则在传输过程中肯定存在错误。许多CRC的硬件解码电路就是按这种方式进行检错的。同时,可以看做是由t（x）和CRC校验码的组合，所以解码时将接收到的二进制数据去掉尾部的r位数据，得到的就是原始数据。解码过程示例：

运行结果：附录（实现代码）：using System; using ; namespace CRC

{ public abstract class Change { oString("x2").ToUpper(); } } return returnStr; } um; } (databuff);eight < max1) && (data[j].Parent == -1)) { max2 = max1; tmp2 = tmp1; tmp1 = j; max1 =

CRC校验原理及步骤

C R C校验原理及步骤 This model paper was revised by the Standardization Office on December 10, 2020

CRC校验原理及步骤什么是CRC校验 CRC即循环冗余校验码：是数据通信领域中最常用的一种查错校验码，其特征是信息字段和校验字段的长度可以任意选定。循环冗余检查（CRC）是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性和完整性。 CRC校验原理：其根本思想就是先在要发送的帧后面附加一个数（这个就是用来校验的校验码，但要注意，这里的数也是二进制序列的，下同），生成一个新帧发送给接收端。当然，这个附加的数不是随意的，它要使所生成的新帧能与发送端和接收端共同选定的某个特定数整除（注意，这里不是直接采用二进制除法，而是采用一种称之为“模2除法”）。到达接收端后，再把接收到的新帧除以（同样采用“模2除法”）这个选定的除数。因为在发送端发送数据帧之前就已通过附加一个数，做了“去余”处理（也就已经能整除了），所以结果应该是没有余数。如果有余数，则表明该帧在传输过程中出现了差错。模2除法：模2除法与算术除法类似，但每一位除的结果不影响其它位，即不向上一位借位，所以实际上就是异或。在循环冗余校验码（CRC）的计算中有应用到模2除法。例： CRC校验步骤：

CRC校验中有两个关键点，一是预先确定一个发送送端和接收端都用来作为除数的二进制比特串（或多项式），可以随机选择，也可以使用国际标准，但是最高位和最低位必须为1；二是把原始帧与上面计算出的除数进行模2除法运算，计算出CRC码。具体步骤： 1. 选择合适的除数 2. 看选定除数的二进制位数，然后再要发送的数据帧上面加上这个位数-1位的0，然后用新生成的帧以模2除法的方式除上面的除数，得到的余数就是该帧的CRC校验码。注意，余数的位数一定只比除数位数少一位，也就是CRC校验码位数比除数位数少一位，如果前面位是0也不能省略。 3. 将计算出来的CRC校验码附加在原数据帧后面，构建成一个新的数据帧进行发送；最后接收端在以模2除法方式除以前面选择的除数，如果没有余数，则说明数据帧在传输的过程中没有出错。 CRC校验码计算示例：现假设选择的CRC生成多项式为G（X）= X4+ X3+ 1，要求出二进制序列的CRC校验码。下面是具体的计算过程： ①将多项式转化为二进制序列，由G（X）= X4+ X3+ 1可知二进制一种有五位，第4位、第三位和第零位分别为1，则序列为11001 ②多项式的位数位5，则在数据帧的后面加上5-1位0，数据帧变为，然后使用模2除法除以除数11001，得到余数。【补几位0与x的最高次幂相同，模除就是进行异或】

CRC16校验C语言程序源码 (附完整的可执行的C语言代码)

CRC16校验C语言程序源码（附完整的可执行的C语言代码） //CRC16校验在通讯中应用广泛，这里不对其理论进行讨论，只对常见的2种 //实现方法进行测试。方法一：查表法（256长度的校验表）速度快，准确，但是对于单片机设备存储占用大，且校验表长度大，输入时容易出现错误。 // ---------------- POPULAR POLYNOMIALS ---------------- // CCITT: x^16 + x^12 + x^5 + x^0 (0x1021) // CRC-16: x^16 + x^15 + x^2 + x^0 (0x8005) #define CRC_16_POLYNOMIALS 0x8005 const BYTE chCRCHTalbe[] = // CRC 高位字节值表 { 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 }; const BYTE chCRCLTalbe[] = // CRC 低位字节值表 { 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,

CRC16校验-C语言代码

//CRC16校验在通讯中应用广泛，这里不对其理论进行讨论，只对常见的3种 //实现方法进行测试。方法1选用了一种常见的查表方法,类似的还有512字 //节、256字等查找表的，至于查找表的生成,这里也略过。 // ---------------- POPULAR POLYNOMIALS ---------------- // CCITT: x^16 + x^12 + x^5 + x^0 (0x1021) // CRC-16: x^16 + x^15 + x^2 + x^0 (0x8005) #define CRC_16_POLYNOMIALS 0x8005 // -------------------------------------------------------------- // CRC16计算方法1:使用2个256长度的校验表 // -------------------------------------------------------------- const BYTE chCRCHTalbe[] = // CRC 高位字节值表 { 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 }; const BYTE chCRCLTalbe[] = // CRC 低位字节值表{ 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,

crc校验码详细介绍看懂了就会了

循环冗余校验码( CRC)的基本原理是：在K 位信息码后再拼接R位的校验码，整个编码长度为N 位，因此，这种编码又叫( N，K)码。对于一个给定的(N，K)码，可以证明存在一个最高次幂为N-K=R的多项式G(x) 。根据G(x) 可以生成K位信息的校验码，而G(x)叫做这个CRC码的生成多项式。校验码的具体生成过程为：假设发送信息用信息多项式C(X)表示，将C(x) 左移R位，则可表示成C(x)*2 的R次方，这样C(x) 的右边就会空出R位，这就是校验码的位置。通过C(x)*2 的R次方除以生成多项式G(x) 得到的余数就是校验码。编辑本段几个基本概念 1、多项式与二进制数码多项式和二进制数有直接对应关系：x 的最高幂次对应二进制数的最高位，以下各位对应多项式的各幂次，有此幂次项对应1，无此幂次项对应0。可以看出：x 的最高幂次为R，转换成对应的二进制数有R+1位。多项式包括生成多项式G(x)和信息多项式C(x) 。如生成多项式为 G(x)=x^4+x^3+x+1 ，可转换为二进制数码11011。而发送信息位1111 ，可转换为数据多项式为C(x)=x^3+x^2+x+1 。 2、生成多项式是接受方和发送方的一个约定，也就是一个二进制数，在整个传输过程中，这个数始终保持不变。在发送方，利用生成多项式对信息多项式做模2 除生成校验码。在接受方利用生成多项式对收到的编码多项式做模2 除检测和确定错误位置。应满足以下条件： a、生成多项式的最高位和最低位必须为1。 b、当被传送信息( CRC码)任何一位发生错误时，被生成多项式做除后应该使余数不为0。 c、不同位发生错误时，应该使余数不同。 d、对余数继续做除，应使余数循环。 3 CRC码的生成步骤 1、将x 的最高次幂为R的生成多项式G(x) 转换成对应的R+1位二进制数。 2、将信息码左移R位，相当与对应的信息多项式C(x)*2 的R次方。 3、用生成多项式(二进制数)对信息码做除，得到R 位的余数。 4、将余数拼到信息码左移后空出的位置，得到完整的CRC码。例】假设使用的生成多项式是G(x)=x^3+x+1 。4 位的原始报文为1010，求编码后的报文。解：

crc校验码详细介绍看懂了就会了

循环冗余校验码（CRC）的基本原理是：在K位信息码后再拼接R位的校验码，整个编码长度为N位，因此，这种编码又叫（N，K）码。对于一个给定的（N，K）码，可以证明存在一个最高次幂为N-K=R的多项式G(x)。根据G(x)可以生成K位信息的校验码，而G(x)叫做这个CRC码的生成多项式。校验码的具体生成过程为：假设发送信息用信息多项式C(X)表示，将C(x)左移R位，则可表示成C(x)*2的R次方，这样C(x)的右边就会空出R位，这就是校验码的位置。通过C(x)*2的R次方除以生成多项式G(x)得到的余数就是校验码。编辑本段几个基本概念 1、多项式与二进制数码多项式和二进制数有直接对应关系：x的最高幂次对应二进制数的最高位，以下各位对应多项式的各幂次，有此幂次项对应1，无此幂次项对应0。可以看出：x的最高幂次为R，转换成对应的二进制数有R+1位。多项式包括生成多项式G(x)和信息多项式C(x)。如生成多项式为G(x)=x^4+x^3+x+1，可转换为二进制数码11011。而发送信息位1111，可转换为数据多项式为C(x)=x^3+x^2+x+1。 2、生成多项式是接受方和发送方的一个约定，也就是一个二进制数，在整个传输过程中，这个数始终保持不变。在发送方，利用生成多项式对信息多项式做模2除生成校验码。在接受方利用生成多项式对收到的编码多项式做模2除检测和确定错误位置。应满足以下条件： a、生成多项式的最高位和最低位必须为1。 b、当被传送信息（CRC码）任何一位发生错误时，被生成多项式做除后应该使余数不为0。 c、不同位发生错误时，应该使余数不同。 d、对余数继续做除，应使余数循环。 3 CRC码的生成步骤 1、将x的最高次幂为R的生成多项式G(x)转换成对应的R+1位二进制数。 2、将信息码左移R位，相当与对应的信息多项式C(x)*2的R次方。 3、用生成多项式（二进制数）对信息码做除，得到R位的余数。 4、将余数拼到信息码左移后空出的位置，得到完整的CRC码。【例】假设使用的生成多项式是G(x)=x^3+x+1。4位的原始报文为1010，求编码后的报文。解： 1、将生成多项式G(x)=x^3+x+1转换成对应的二进制除数1011。 2、此题生成多项式有4位（R+1），要把原始报文C(x)左移3（R）位变成1010000 3、用生成多项式对应的二进制数对左移3位后的原始报文进行模2除，相当于按位异或： 1010000

CRC16算法原理

CRC算法及C实现学习体会2008-09-20 15:21:13 阅读161 评论0 字号：大中小订阅一、CRC算法原理 CRC校验的基本思想是利用线性编码理论，在发送端根据要传送的k位二进制码序列，以一定的规则产生一个校验用的监督码（既CRC码）r位，并附在信息后边，构成一个新的二进制码序列数共(k+r)位，最后发送出去。在接收端，则根据信息码和CRC码之间所遵循的规则进行检验，以确定传送中是否出错。 16位的CRC码产生的规则是先将要发送的二进制序列数左移16位（既乘以）后，再除以一个多项式，最后所得到的余数既是 CRC码。假设数据传输过程中需要发送15位的二进制信息 g=101001110100001，这串二进制码可表示为代数多项式g(x) = x^14 + x^12 + x^9 + x^8 + x^7 + x^5 + 1，其中g中第k位的值，对应g(x)中x^k的系数。将g(x)乘以x^m，既将g后加m个0，然后除以m阶多项式h(x)，得到的(m-1)阶余项 r(x)对应的二进制码r就是 CRC编码。 h(x)可以自由选择或者使用国际通行标准，一般按照h(x)的阶数m，将CRC算法称为CRC-m，比如CRC-32、CRC-64等。国际通行标准可

以参看 https://www.360docs.net/doc/ff6125249.html,/wiki/Cyclic_redundancy_check g(x)和h(x)的除运算，可以通过g和h做xor（异或）运算。比如将 11001与10101做xor运算：明白了xor运算法则后，举一个例子使用CRC-8算法求101001110100001的效验码。CRC-8标准的h(x) = x^8 + x^7 + x^6 + x^4 + x^2 + 1，既h是9位的二进制串111010101。

CRC16校验产生函数

CRC16校验产生函数 /****************************************************************************** * Function Name : crc16 * Input : 数据缓冲区指针：puchMsg ，数据长度：usDataLen * Return : 16 位CRC校验码 * Description : 产生16 位CRC校验码 *******************************************************************************/ INT16U crc16(INT8U *puchMsg, INT8U usDataLen) { INT8U uchCRCHi=0xFF ; /* 高CRC字节初始化*/ INT8U uchCRCLo=0xFF ; /* 低CRC字节初始化*/ INT16U uIndex; /* CRC循环中的索引*/ while(usDataLen--) /* 传输消息缓冲区*/ { uIndex =uchCRCHi^*puchMsg++ ; /* 计算CRC */ uchCRCHi=uchCRCLo^auchCRCHi[uIndex] ; uchCRCLo=auchCRCLo[uIndex]; } return (uchCRCHi<<8|uchCRCLo); } /* CRC 高位字节值表*/ const INT8U code 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,

CRC循环冗余校验(CCITT-16)

CRC 循环冗余校验（CCITT-16) START MOVLW DATAe MOVWF ADDR ；将[e 00]余式表首地址DATAe 存入ADDR SWAPF BYTEa ，0ANDLW 0FH ；求e 和e 指定的[e 00]余式高字节的相对地址ADDWF ADDR ，1 ；取其绝对地址，存入ADDR MOVF ADDR ，0 ；把这一绝对地址再存入W CALL TABLE ；查表，返回时h e 00放 W 中 MOVWF RESULTh ；把 h e 00 存 RESULTh MOVLW 16ADDWF ADDR ，0；求e 指定的[e 00] 式低字节的绝对地址CALL TABLE ；查表，返回时l e 00放W 中 MOVWF RESULTl ；把l e 00存入RESUL MOVLW DATAf MOVWF ADDR ；将[f 00]余式表首址DATAf 存入ADDR MOVF BYTEa ，0ANDLW 0FH ；求f 和f 指定的[f 0 余式高字节的相对址 ADDWF ADDR ，1；取其绝对地址，存ADDR MOVF ADDR ，0；把这一绝对地址再存W CALL TABLE ；查表，返回时h f 00放 W 中 XORWF RESULTh ，0；h e 00与h f 00异或， h a 00，存入W XORWF BYTEb ，0；h a 00与b 异或，h abc ，存入W MOVF BYTEa ；h abc 存入BYTEa MOVLW 16ADDWF ADDR ，0；求f 指定的[f 00]式低字节的绝对地址CALL TABLE ；查表,返回时l f 00放W 中

CRC校验码的原理

CRC 校验码的原理在通信与数字信号处理等领域中循环冗余校验码（Cyclic Redundancy Check,CRC ）是一种很常用的设计。一般来说数据通信中的编码可以分为信源编码和信道编码两大类，其中，为了提高数据通信的可靠性而采取的编码称为信道编码，即抗干扰编码。在通信系统中，要求数据传输过程中的误码率足够低，而为了降低数据传输过程中的误码率，经常采用的一种方法是差错检测控制。在实际的通信系统中，差错检测控制的主要方法又3种：前向纠错（FEC ），自动重发（ARQ ）和反馈检验法。FEC 指接收端不仅能够在收到的信码中发现错码，而且还能够纠正错码。一般来说，这种方法不需要反向信道，实时性很好，不过设备较复杂。ARQ 是指接收端在收到的信码中检测出错码时，即设法通知发送端重新发送信号，直到能够正确接收为止。通常，这种方法只用来检测误码，而且只能在双向信道中使用。反馈检验法是指接收端将收到的信码一字不差地转发回发送端，同时与原发送信码进行比较，如果有错，则发端重发。这种方法的原理和设备都比较简单，但需要双向信道的支持，而且传输效率低下；通过实践检验，在这三中方法中，如果传输过程中的误码率较低，那么采用前向纠错法比较理想，但如果误码率较高时，这种方法又会出现“乱纠”的现象；在网络通信中，广泛的采用差错检测方法时自动请求重发，这种方法只要检错功能即可；反馈检验法时前向纠错法和自动请求重发的结合。在实现差错检测控制的众多方法中，循环冗余校验就是一类重要的线性分组码。它时一种高效的差错控制方法，它广泛应用于测控及数据通信领域，同时具有编码和解码方法简单，检错能力强，误判概率很低和具有纠错能力等优点。循环冗余校验码实现的方法 CRC 的基本原理就是在一个P 位二进制数据序列之后附加一个R 位二进制检验码序列，从而构成一个总长位N=P+R 位的二进制序列。例如，P 位二进制数据序列D=[d 1-p d 2-p …d 1d 0]，R 位二进制检验码R = [r 1-r r 2-r …r 1r 0],那么所得到的这个N 位二进制序列就是M=[d 1-p d 2-p …d 1d 0 r 1-r r 2-r …r 1r 0]，这里附加在数据序列之后的CRC 码与数据序列的内容之间存在着某种特定的关系。如果在数据传输过程中，由于噪声或传输特性不理想而使数据序列中的某一位或某些位发生错误，这种特定关系就会被破坏。可见在数据的接收端通过检查这种特定关系，可以很容易地实现对数据传输正确性的检验。在CRC 中，检验码R 使通过对数据序列D 进行二进制除法取余式运算得到的，他被一个称为生成多项式的（r+1）位二进制序列G=[g r g 1-r …g 1g 0]来除，具体的多项式除法形式如下： ) ()(x G x D x r =Q(x)+ ) ()(x G x R 其中，)(x D x r 表示将数据序列D 左移r 位，即在D 的末尾再增加r 个0位；Q （x ）代表这一除法所得的商，R （x ）就是所需的余式。此外，这一运算关系还可以表示为 ?? ? ???=)()(Re )(x G x D x x R r ?? ? ? ??=)()(Re )(x G x M x R 通过上面CRC 基本原理的介绍，可以发现生成多项式使一个非常重要的概念，它决定了CRC 的具体算法。目前，生成多项式具有一下一些通用标准，其中CRC -12，CRC -16，

crc16校验原理

CRC校验码原理

CRC16校验程序

CRC校验实验报告

CRC校验原理及步骤

CRC16校验C语言程序源码 (附完整的可执行的C语言代码)

CRC16校验-C语言代码

crc校验码详细介绍看懂了就会了

crc校验码 详细介绍看懂了就会了

CRC16算法原理

CRC16校验产生函数

CRC循环冗余校验(CCITT-16)

CRC校验码的原理

CRC16校验C语言程序源码-(附完整的可执行的C语言代码)

crc校验码详细介绍看懂了就会了