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

合集下载

16位CRC校验码计算程序

16位CRC校验码计算程序在计算机领域，CRC（Cyclic Redundancy Check）是一种常用的错误检测码，用于检测数据传输或存储过程中的错误。

CRC校验码通常是一个16位的二进制数，用于验证数据的完整性。

计算16位CRC校验码的方法如下：1.定义一个16位寄存器，并将其初始化为0。

2.将待校验的数据按位分割，并逐个与16位寄存器的最高位进行异或操作。

3.对每个数据位重复上述异或操作。

4.最后将16位寄存器的值作为CRC校验码。

下面是一个简单的Python代码示例，演示了如何计算16位CRC校验码：```pythondef calculate_crc16(data):crc = 0xFFFF # 16位寄存器，初始值为0xFFFFfor byte in data:crc ^= (byte << 8) # 将当前数据字节与寄存器的高八位进行异或操作for _ in range(8):if crc & 0x8000: # 检查寄存器的最高位是否为1crc = (crc << 1) ^ 0x1021 # 若为1，则将寄存器左移一位，并与0x1021进行异或操作else:crc <<= 1 # 若为0，则将寄存器左移一位return crc & 0xFFFF#示例数据data = [0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE]#计算CRC校验码crc16 = calculate_crc16(data)print(f"CRC16校验码：0x{crc16:04X}")```在上述代码中，`data`列表用于存储待校验的数据，`calculate_crc16`函数用于计算16位CRC校验码。

最后，根据计算结果输出CRC16校验码。

值得注意的是，具体的CRC校验码算法可能因应用场景的不同而有所不同。

C语言实现CRC16校验

CRC校验C语言实现，转载请注明出处，谢谢CRC(Cyclic Redundancy Check)校验应用较为广泛，以前为了处理简单，在程序中大多数采用LRC(Longitudinal Redundancy Check)校验，LRC校验很好理解，编程实现简单。

用了一天时间研究了CRC的C语言实现，理解和掌握了基本原理和C语言编程。

结合自己的理解简单写下来。

1、CRC简介CRC检验的基本思想是利用线性编码理论，在发送端根据要传送的k位二进制码序列，以一定的规则产生一个检验码r位(就是CRC码)，附在信息后面，构成一个新的二进制码序列数共(k+r)位，最后发送出去。

接收端根据同样的规则校验，以确定传送中是否出错。

接收端有两种处理方式：1、计算k位序列的CRC码，与接收到的CRC比较，一致则接收正确。

2、计算整个k+r位的CRC码，若为0，则接收正确。

CRC码有多种检验位数，8位、16位、32位等，原理相同。

16位的CRC码产生的规则是先将要发送的二进制序列数左移16位（即乘以2的16次方后），除以一个多项式，最后所得到的余数就是CRC码。

求CRC码所采用的是模2运算法则，即多项式除法中采用不带借位的减法运算，运算等同于异或运算。

这一点要仔细理解，是编程的基础。

CRC-16: (美国二进制同步系统中采用) G(X) = X16 + X15 + X2 + 1CRC-CCITT: (由欧洲CCITT推荐) G(X) = X16 + X12 + X5 + 1CRC-32: G(X) = X32 + X26 + X23 + X22 + X16 +X12 + X11 + X10 + X8 + X7 + X5 + X4 + X2 + X1 + 12、按位计算CRC采用CRC-CCITT多项式，多项式为0x11021，C语言编程时，参与计算为0x1021，这个地方得深入思考才能体会其中的奥妙，分享一下我的思路：当按位计算CRC时，例如计算二进制序列为1001 1010 1010 1111时，将二进制序列数左移16位，即为1001 1010 1010 1111 (0000 0000 0000 0000)，实际上该二进制序列可拆分为1000 0000 0000 0000 (0000 0000 0000 0000) + 000 0000 0000 0000 (0000 0000 0000 0000) + 00 0000 0000 0000 (0000 0000 0000 0000) + 1 0000 0000 0000 (0000 0000 0000 0000) + ……现在开始分析运算：<1>对第一个二进制分序列求余数，竖式除法即为0x10000 ^ 0x11021运算，后面的0位保留；<2>接着对第二个二进制分序列求余数，将第一步运算的余数*2后再和第二个二进制分序列一起对0x11021求余，这一步理解应该没什么问题。

crc16 c语言代码

} else {
crc >>= 1; //如果为0，则只将CRC寄存器右移一位
}
}
}
return crc;
}
int main() {
unsigned char data[] = {0x01, 0x02, 0x03, 0x04, 0x05}; //要计算CRC16校验码的数据
unsigned short crc = crc16(data, sizeof(data)); //计算CRC16校验码
#include <stdio.h>
#define POLY 0x8005 // CRC-16-CCITT多项式
unsigned shoБайду номын сангаасt crc16(unsigned char *data, int length) {
unsigned short crc = 0xFFFF; //初始值为0xFFFF
printf("CRC16校验码为：%04X\n", crc); //输出CRC16校验码
return 0;
}
这个代码使用了一个简单的算法来计算CRC16校验码。它首先将初始值设置为0xFFFF，然后将数据位逐个异或到CRC寄存器中。接下来，它检查最低有效位是否为1，如果是，则将CRC寄存器右移一位并异或多项式；否则，只将CRC寄存器右移一位。最后，返回计算得到的CRC16校验码。
int i, j;
for (i = 0; i < length; i++) {
crc ^= (unsigned short)(data[i]); //将数据位异或到CRC寄存器中
for (j = 0; j < 8; j++) {

最详细易懂的CRC16校验原理附源程序

最详细易懂的CRC16校验原理附源程序最详细易懂的CRC-16校验原理（附源程序）1、循环校验码（CRC码）：是数据通信领域中最常用的一种差错校验码，其特征是信息字段和校验字段的长度可以任意选定。

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

例642532+x+1对应的代码101111+x+x+1，而多项式为x。

+x如：代码对应的多项式为x +x+x 标准CRC生成多项式如下表：名称生成多项式简记式* 标准引用CRC-4 x4+x+1 3 ITU G.704CRC-8 x8+x5+x4+1 0x31CRC-8 x8+x2+x1+1 0x07CRC-8 x8+x6+x4+x3+x2+x1 0x5ECRC-12 x12+x11+x3+x+1 80FCRC-16 x16+x15+x2+1 8005 IBM SDLCCRC16-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-FCSCRC-32c x32+x28+x27+...+x8+x6+1 1EDC6F41 SCTP3、CRC-16校验码的使用：现选择最常用的CRC-16校验，说明它的使用方法。

根据Modbus协议，常规485通讯的信息发送形式如下：地址功能码数据信息校验码1byte 1byte nbyte 2byteCRC校验是前面几段数据内容的校验值，为一个16位数据，发送时，低8位在前，高8为最后。

1010，校验字段为：: 1011001信息字段代码为例如：发送方：发出的传输字段为: 1 0 1 1 0 0 1 1 0 10信息字段校验字段接收方：使用相同的计算方法计算出信息字段的校验码，对比接收到的实际校验码，如果相等及信息正确，不相等则信息错误；或者将接受到的所有信息除多项式，如果能够除尽，则信息正确。

最详细易懂的CRC-16校验原理(附源程序)

最详细易懂的CRC-16校验原理（附源程序）1、循环校验码（CRC码）：是数据通信领域中最常用的一种差错校验码，其特征是信息字段和校验字段的长度可以任意选定。

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

例如：代码对应的多项式为X6+X4+X2+X+1，而多项式为X5+X3+X2+X+1对应的代码101111 o标准CRC生成多项式如下表：名称生成多项式简记式*标准引用CRC-4 x4+x+1 3 ITU G.704CRC-8 x8+x5+x4+1 0x31CRC-8 x8+x2+x1+1 0x07CRC-8x8+x6+x4+x3+x2+x10x5ECRC-12 x12+x11+x3+x+1 80FCRC-16 x16+x15+x2+1 8005 IBM SDLCCRC16-CCITT x16+x12+x5+1 1021 ISO HDLC, ITU X.25, V.34/V.41/V.42, PPP-FCSCRC-32 x32+x26+x23+...+x2+x+1 04C11DB7 ZIP, RAR, IEEE 802 LAN/FDDI,IEEE 1394, PPP-FCSCRC-32c x32+x28+x27+...+x8+x6+1 1EDC6F41 SCTP3、CRC-16校验码的使用：现选择最常用的CRC-16校验，说明它的使用方法。

例如：信息字段代码为：1011001，校验字段为：1010。

发送方：发出的传输字段为：1 0 1 1 0 0 1 1 0 10信息字段校验字段接收方：使用相同的计算方法计算出信息字段的校验码，对比接收到的实际校验码，如果相等及信息正确，不相等则信息错误；或者将接受到的所有信息除多项式，如果能够除尽，贝y 信息正确。

c#实现16位crc校验源代码

void Crc(byte[] buffer);
void Crc(byte[] buf, int off, int len);
}
}
namespace CRC
{
/// <summary>
/// CRC16 的摘要说明。
/// </summary>
public class p
{
public static void Main()
{
}
public class CRC16 : ICRC
{
#region CRC 16 位校验表
/// </summary>
public void Reset()
{
crc = 0;
}
/// <summary>
/// Crc16
Crc(buffer, 0, buffer.Length);
}
/// <summary>
/// Crc16
/// </summary>
/// <param name="buf"></param>
Crc(buf[i]);
}
}
}
}
}
/// <param name="bval"></param>
public void Crc(int bval)
{
ushort h = (ushort)((crc >> 12) & 0x0f);
/// Crc16

crc16 citt false c语言

crc16 citt false c语言CRC16是一种常用的循环冗余校验算法，它可以用于检测和纠正数据传输中的错误。

在C语言中，我们可以使用CRC16算法来计算校验和，并判断数据的完整性。

CRC16算法采用的是多项式除法，具体的计算过程如下：1. 首先，我们需要定义一个16位的CRC寄存器，初始值为0xFFFF。

2. 然后，我们将待校验的数据按位进行处理，从高位到低位逐个与CRC寄存器进行异或运算。

3. 接着，我们将CRC寄存器的值右移一位，如果最低位是1，则将寄存器与一个预设的固定值（0xA001）进行异或运算。

4. 重复上述步骤，直到所有的数据位都被处理完毕。

5. 最后，CRC寄存器的值就是计算得到的校验和。

在C语言中，我们可以通过编写一个函数来实现CRC16的计算。

下面是一个示例代码：```c#include <stdio.h>#include <stdint.h>uint16_t crc16(uint8_t *data, int length){uint16_t crc = 0xFFFF;for (int i = 0; i < length; i++) {crc ^= (uint16_t)data[i];for (int j = 0; j < 8; j++) {if (crc & 0x0001) {crc = (crc >> 1) ^ 0xA001;} else {crc >>= 1;}}}return crc;}int main(){uint8_t data[] = {0x01, 0x02, 0x03, 0x04, 0x05}; int length = sizeof(data) / sizeof(data[0]);uint16_t checksum = crc16(data, length);printf("CRC16 checksum: 0x%04X\n", checksum);return 0;}```在上述代码中，我们首先定义了一个crc16函数，它接受一个指向数据数组的指针和数据的长度作为输入，返回一个16位的校验和。

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

CRC16校验C 语言程序源码（附完整的可执行的 C 语言代码）//CRC16校验在通讯中应用广泛，这里不对其理论进行讨论，只对常见的 2种//实现方法进行测试。

方法一：查表法（256长度的校验表）速度快，准确，但是对于单片机设备存储占用大，且校验表长度大，输入时容易岀现错误 // .................. --POPULAR POLYNOMIALS ....................// CCITT: x A 16 + x A 12 + x A 5 + x A 0(0x1021) // CRC-16: x A 16 + xA15 + xA2 + xA0(0x8005)#defi neCRC_16_POLYNOMIALS0x8005const BYTE chCRCHTalbe[]=// CRC 高位字节值表{0x00, 0xC1, 0x81, 0x40, 0x01, OxCO, 0x80, 0x41, 0x01, OxCO, 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 }；con st 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, 0x1代 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3, 0x11, OxD1, OxDO, 0x10, OxFO, 0x30, 0x31, OxF1,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}；WORD CRC16_1(BYTE* pchMsg, WORD wDataLe n){BYTE chCRCHi = 0xFF; // 高CRC字节初始化BYTE chCRCLo = 0xFF; // 低CRC字节初始化WORD win dex; // CRC 循环中的索引while (wDataLe n--){// 计算CRCwin dex = chCRCLo A *pchMsg++ ;chCRCLo = chCRCHi A chCRCHTalbe[wl ndex]; chCRCHi =chCRCLTalbe[wi ndex];}return ((chCRCHi << 8) | chCRCLo);}方法一：列表法(简单表)con st WORD wCRCTalbeAbs[]={0x0000, 0xCC01, 0xD801, 0x1400, 0xF001, 0x3C00, 0x2800, 0xE401, 0xA001, 0x6C00, 0x7800,0xB401,0x5000, 0x9C01,0x8801,0x4400,}；WORD CRC16_2(BYTE* pchMsg, WORD wDataLe n){WORD wCRC = OxFFFF;WORD i;BYTE chChar;for (i = 0; i < wDataLe n; i++){chChar = *pchMsg++;wCRC = wCRCTalbeAbs[(chChar A wCRC)& 15] A (wCRC>> 4);wCRC = wCRCTalbeAbs[((chChar >> 4) A wCRC) & 15] A (wCRC >> 4);}return wCRC;}方法二：定义法根据CRC16/MODBUS理直接计算，算法简单但对单片机计算压力大。

Modbus协议CRC16校验和LRC校验C语言实现

Modbus协议CRC16校验和LRC校验C语言实现Modbus协议RTU模式使用CRC16校验Modbus协议Ascii模式使用LRC校验CRC16校验C语言实现代码如下，使用2个文件crc16.c和crc16.hcrc16.c代码如下：#include"crc16.h"/* CRC16计算函数，ptr-数据指针，len-数据长度，返回值-计算出的CRC16数值*/ unsigned int GetCRC16(unsigned char *ptr, unsigned char len){unsigned int index;unsigned char crch = 0xFF; //高CRC字节unsigned char crcl = 0xFF; //低CRC字节unsigned char TabH[] = { //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} ;unsigned char TabL[] = { //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, 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} ;while (len--) //计算指定长度的CRC{index = crch ^ *ptr++;crch = crcl ^ TabH[index];crcl = TabL[index];}return (unsigned int)((crch<<8) | crcl);}crc16.h代码如下：#ifndef __CRC16_H#define __CRC16_H/* CRC16计算函数，ptr-数据指针，len-数据长度，返回值-计算出的CRC16数值*/ unsigned int GetCRC16(unsigned char *ptr, unsigned char len);#endif使用方法如下：假设数组为unsigned char send[8]={0x01,0x03,0x20,0x00,0x00,0x01,0x8F,0xCA};对数组进行CRC16校验计算，调用计算函数unsigned int crc;crc = GetCRC16(send, 6); //计算CRC校验值send[6] = crc >> 8; //CRC高字节把校验插回数组send[7] = crc & 0xFF; //CRC低字节把校验插回数组LRC校验C语言实现代码如下，使用2个文件lrc.c和lrc.hlrc.c代码如下：#include"lrc.h"/* LRC计算函数，ptr-数据指针，len-数据长度，返回值-计算出的LRC数值*/ unsigned char GetLRC(unsigned char *ptr, unsigned char len){signed int result1=0;unsigned char result2=0;unsigned char i=0;for(i=0;i<len;i++){result1+=*ptr++;}result1=0x100-result1;result2=(unsigned char)result1;return result2;}lrc.h代码如下：#ifndef __LRC_H#define __LRC_H/* LRC计算函数，ptr-数据指针，len-数据长度，返回值-计算出的LRC数值*/ unsigned char GetLRC(unsigned char *ptr, unsigned char len);#endif使用方法如下：假设数组为unsigned char send[7]={0x01,0x06,0x20,0x01,0x9c,0x41,0xfb};对数组进行LRC校验计算，调用计算函数unsigned char lrc;lrc = GetLRC(send, 6); //计算CRC校验值send[6] = lrc ; // 把校验插回数组。

CRC-16校验C#代码

CRC-16校验C#代码[csharp]01. using System;02. using System.Collections.Generic;03. using System.Text;04. using System.Runtime.Serialization.Formatters.Binary;05. using System.IO;06.07. namespace smsForCsharp.CRC08. {09. /// <summary>10. /// 消息CRC校验算法11. /// </summary>12. public class CRC13. {14.15. public static String getCrc16Code(String crcString)16. {17.18. // 转换成字节数组19. byte[] creBytes = HexString2Bytes(crcString);20.21. // 开始crc16校验码计算22. CRC16Util crc16 = new CRC16Util();23. crc16.reset();24. crc16.update(creBytes);25. int crc = crc16.getCrcValue();26. // 16进制的CRC码27. String crcCode = Convert.ToString(crc, 16).ToUpper();28. // 补⾜到4位29. if (crcCode.Length < 4)30. {31. // crcCode = StringUtil.lefgPadding(crcCode, '0', 4);32. crcCode = crcCode.PadLeft(4, '0');33. }34. return crcCode;35. }36.37.38. public static String RealHexToStr(String str)39. {40. String hText = "0123456789ABCDEF";41. StringBuilder bin = new StringBuilder();42. for (int i = 0; i < str.Length; i++)43. {44. bin.Append(hText[str[i] / 16]).Append(hText[str[i] % 16]).Append(' ');45. }46. return bin.ToString();47. }48. /**49. * ⼗六进制字符串转换成字节数组50. *51. * @param hexstr52. * @return53. */54. public static byte[] HexString2Bytes(String hexstr)55. {56. byte[] b = new byte[hexstr.Length / 2];57. int j = 0;58. for (int i = 0; i < b.Length; i++)59. {60. char c0 = hexstr[j++];61. char c1 = hexstr[j++];62. b[i] = (byte)((parse(c0) << 4) | parse(c1));63. }64. return b;65. }66.67.68. /**69. * 16进制char转换成整型70. *71. * @param c72. * @return73. */74. public static int parse(char c)77. return (c - 'a' + 10) & 0x0f;78. if (c >= 'A')79. return (c - 'A' + 10) & 0x0f;80. return (c - '0') & 0x0f;81. }82.83.84.85.86. public static string ByteArrayToHexString(byte[] data)//字节数组转为⼗六进制字符串87. {88. StringBuilder sb = new StringBuilder(data.Length * 3);89. foreach (byte b in data)90. sb.Append(Convert.ToString(b, 16).PadLeft(2, '0').PadRight(3, ' '));91. return sb.ToString().ToUpper();92. }93.94. }95.96.97.98.99. public class CRC16Util100. {101.102. /**CRC值*/103. private int value = 0xffff;104.105. private static int[] CRC16_TABLE = {106. 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,107. 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,108. 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,109. 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,110. 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,111. 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,112. 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,113. 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,114. 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,115. 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,116. 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,117. 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,118. 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,119. 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,120. 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,121. 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,122. 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,123. 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,124. 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,125. 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,126. 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,127. 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,128. 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,129. 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,130. 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,131. 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,132. 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,133. 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,134. 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,135. 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,136. 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,137. 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78138. };139.140. /**141. * 计算⼀个字节数组的CRC值142. * @param data143. */144. public void update(byte[] data)145. {146. //int fcs = 0xffff;147. for (int i = 0; i < data.Length; i++)148. {149. // 1.value 右移8位(相当于除以256)150. // 2.value与进来的数据进⾏异或运算后再与0xFF进⾏与运算151. // 得到⼀个索引index，然后查找CRC16_TABLE表相应索引的数据152. // 1和2得到的数据再进⾏异或运算。

crc16校验算法c语言

crc16校验算法c语言crc16校验算法是一种常用的数据校验方法，它可以检测出数据传输或存储过程中的错误，并提供纠错的依据。

crc16校验算法的原理是将待校验的数据看作一个多项式，用一个固定的生成多项式对其进行除法运算，得到的余数就是crc16校验码。

生成多项式的选择会影响crc16校验算法的性能，不同的应用场景可能需要不同的生成多项式。

本文主要介绍一种常用的生成多项式，即CRC-CCITT，它的二进制表示为0x1021，十六进制表示为0x11021。

本文将介绍三种实现crc16校验算法c语言的方法，分别是按位计算、按半字节计算和按单字节计算。

这三种方法的原理都是基于生成多项式对数据进行除法运算，但是具体的实现方式有所不同，各有优缺点。

下面分别介绍这三种方法，并给出相应的c语言代码。

按位计算按位计算是最直接的实现方式，它是将待校验的数据和生成多项式按位进行异或运算，得到余数。

这种方法的优点是不需要额外的存储空间，缺点是效率较低，需要循环处理每一位数据。

按位计算的c语言代码如下：#include<stdint.h>#define CRC_CCITT 0x1021//生成多项式//函数名称：crc_cal_by_bit;按位计算CRC//函数参数：uint8_t * ptr;指向发送缓冲区的首字节// uint32_t len;要发送的总字节数//函数返回值：uint16_tuint16_t crc_cal_by_bit(uint8_t*ptr, uint32_t len) {uint32_t crc =0xffff; //初始值while (len--!=0) {for (uint8_t i =0x80; i !=0; i >>=1) { //处理每一位数据crc <<=1; //左移一位if ((crc &0x10000) !=0) //如果最高位为1，则异或生成多项式crc ^=0x11021;if ((*ptr & i) !=0) //如果当前数据位为1，则异或生成多项式crc ^= CRC_CCITT;}ptr++; //指向下一个字节}uint16_t retCrc = (uint16_t)(crc &0xffff); //取低16位作为结果return retCrc;}按半字节计算按半字节计算是对按位计算的优化，它是将待校验的数据和生成多项式按半字节（4位）进行异或运算，得到余数。

CRC16C语言实现

CRC16C语⾔实现最近看到⼀个实现crc16的⼩程序，刚开始，不明觉厉，于是花了⼀个周末去know how。

CRC(Cyclic Redundancy Check)循环冗余校验是常⽤的数据校验⽅法。

先说说什么是数据校验。

数据在传输过程（⽐如通过⽹线在两台计算机间传⽂件）中，由于传输信道的原因，可能会有误码现象（⽐如说发送数字5但接收⽅收到的却是6），如何发现误码呢？⽅法是发送额外的数据让接收⽅校验是否正确，这就是数据校验。

最容易想到的校验⽅法是和校验，就是将传送的数据(按字节⽅式)加起来计算出数据的总和，并将总和传给接收⽅，接收⽅收到数据后也计算总和，并与收到的总和⽐较看是否相同。

如果传输中出现误码，那么总和⼀般不会相同，从⽽知道有误码产⽣，可以让发送⽅再发送⼀遍数据。

CRC校验也是添加额外数据做为校验码，这就是CRC校验码，那么CRC校验码是如何得到的呢？⾮常简单，CRC校验码就是将数据除以某个固定的数（⽐如ANSI-CRC16中，这个数是0x18005），所得到的余数就是CRC校验码。

那这⾥就有⼀个问题，我们传送的是⼀串字节数据，⽽不是⼀个数据，怎么将⼀串数字变成⼀个数据呢？这也很简单，⽐如说2个字节B1，B2,那么对应的数就是(B1<<8)+B2；如果是3个字节B1，B2，B3，那么对应的数就是((B1<<16)+(B2<<8)+B3),⽐如数字是0x01,0x02,0x03，那么对应的数字就是0x10203；依次类推。

如果字节数很多，那么对应的数就⾮常⾮常⼤，不过幸好CRC只需要得到余数，⽽不需要得到商。

从上⾯介绍的原理我们可以⼤致知道CRC校验的准确率，在CRC8中出现了误码但没发现的概率是1/256，CRC16的概率是1/65536，⽽CRC32的概率则是1/2^32，那已经是⾮常⼩了，所以⼀般在数据不多的情况下⽤CRC16校验就可以了，⽽在整个⽂件的校验中⼀般⽤CRC32校验。

C语言实现的CRC16CCITT-FALSE校验码函数

//MODBUS CRC-16表 8005 逆序 const unsigned short g_McRctable_16[256] = {
0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,

CRC16 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寄存器将移出的最高1bitunsigned 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校验值。

CRC-16校验-完整代码

CRC-16校验完整代码CRC-16校验完整代码通信领域经常用到CRC校验。

这里把CRC-16的代码转发一下。

不过，我推荐一个用于生成各种校验码的开源软件 Fsum frontend它的开源项目网址是：/下载其源代码，可看到各种算法，但不是用c写的。

该软件的用处是，可以验证你的算法。

CRC-16 IBM x 16 + x 15 + x 2 + 1CRC编码的原理，网上有很多，简单的说就是将数据用生成式进行模2除法。

这里我主要写一下，查表法的原理。

一、原理：数据项： <BnBn-1Bn-2Bn-3,...,B3B2B1>先查表获得Bn的两字节余式，将该余式的高8位与Bn-1进行模2运算，假定B'n-1,低8位与Bn-2进行模2运算，假定结构为B'n-2，得到< B'n-1B'n-2Bn-3,...,B3B2B1 >,以此类推，最终获得两字节的CRC码.(参考字节型CRC算法实现一文)二、实现以下代码中中的查表法来自于 Linux-2.6.17，定义法是根据定义编写的，我使用随机数对两种方法进行了比对，结果一致#include <stdio.h>#include <stdlib.h>#include<math.h>typedef unsigned intu16;typedef unsigned char u8;u16 const crc16_table[256] = { 0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1,0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880,0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, 0x1400,0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0,0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80,0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01,0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0,0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441, 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01,0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1,0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80,0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541,0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440, 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81,0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0,0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040};static inline u16 crc16_byte(u16 crc, const u8 data){ return (crc >> 8) ^crc16_table[(crc ^ data) & 0xff];}/*** crc16 - compute the CRC-16 for the data buffer* @crc: previous CRC value*@buffer: data pointer* @len: number of bytes in the buffer** Returns the updated CRC value.*/u16 crc16(u16 crc, u8 const *buffer, u16 len){ while (len--) crc = crc16_byte(crc, *buffer++); return crc;}/*** crc16 - compute the CRC-16 for the data buffer according to the definition* @crc: previous CRC value* @buffer: data pointer* @len: number of bytes in the buffer** Returns the updated CRC value.*/u16 crc16_calculate(u16 crc,u8 const *buffer,u16 len){ u16 i,j; u8 data; for ( j = 0; j < len; j++) { data= buffer[j]; for ( i = 0; i < 8; i++) { crc = ((data ^ (u8)crc) & 1) ? ((crc >> 1) ^ 0xA001) : (crc >> 1); data>>= 1; } } return crc;}int main(){ u16 crc1,crc2; u8 test[32] ; u8 i; while(1) { for(i=0;i<32;i++) test[i]=rand(); crc1=0; crc2=0; // crc=crc16(0,test,6); crc1=crc16(crc1,test,6);printf("CRC=%d/n",crc1); crc2=crc16_calculate(crc2,test,6); printf("CRC=%d/n",crc2); if(crc1!=crc2) break; } return 0;}。

CRC16校验算法实现

CRC16校验算法实现CRC16（Cyclic Redundancy Check）是一种常用的校验算法，用于检测和纠正数据传输中的错误。

CRC16校验算法利用一个16位的除数对待校验的数据进行多项式除法运算得到一个16位的校验码。

以下是关于CRC16校验算法的实现解释：1.CRC16多项式和初始值-CRC-16/CCITT(0x1021)多项式：x^16+x^12+x^5+1-CRC-16/XMODEM(0x8408)多项式：x^16+x^12+x^5+1-CRC-16/USB(0x8005)多项式：x^16+x^15+x^2+1另外，CRC16算法需要一个初始值作为起始状态，常用的初始值是0xFFFF。

2.算法步骤-初始化：将CRC寄存器初始值设置为0xFFFF。

-逐位计算：对每个数据位进行计算，包括数据的每个字节和最低的一位，直到所有位都被处理。

-异或操作：如果当前位为1，将CRC寄存器的值和多项式进行异或操作。

-位移操作：将CRC寄存器的值向右移动一位。

-判断：如果当前位为1，执行一个异或操作；否则，跳过这一步。

-重复：重复以上几个步骤，直到所有数据位都被处理。

-最终结果：得到的CRC寄存器就是CRC16校验码。

3.实际编程实现以下是使用Python语言实现CRC16校验算法的示例代码：```pythondef crc16(data):crc = 0xFFFFpoly = 0x1021for byte in data:crc ^= (byte << 8)for _ in range(8):if crc & 0x8000:crc = (crc << 1) ^ polyelse:crc <<= 1crc &= 0xFFFFreturn crc```这个函数`crc16`接受一个字节串作为输入，并返回计算得到的CRC16校验码。

4.使用示例以下是使用示例，演示如何使用上述的`crc16`函数计算CRC16校验码：```pythondata = b'Hello, World!' # 待校验的数据crc = crc16(data) # 计算CRC16校验码print(hex(crc)) # 输出十六进制格式的校验码```在该示例中，输入数据为字符串"Hello, World!"，将其转换为字节串，然后调用`crc16`函数进行校验码计算，最后将结果以十六进制格式打印出来。