CRC查表法 计算法
一种CRC并行计算原理及实现方法
一种CRC并行计算原理及实现方法一种常用的CRC并行计算原理及实现方法是通过使用查表法（Table-Driven）。
CRC（循环冗余校验码）是一种常用的数据校验方法，它通过对数据进行异或运算，生成一个校验值，再将校验值附加到数据中传输，接收方根据接收到的数据和附加的校验值进行计算，如果计算的结果与已知的校验值相同，则数据传输没有错误，否则存在错误。
在CRC并行计算中，常见的被检验的数据流是按位顺序传输的。
为了加速计算过程，可以使用查表法来并行计算CRC。
查表法的基本原理是预先计算不同输入字节（8位）对应的CRC，然后利用这些预先计算的结果来进行CRC计算。
具体步骤如下：1.预先计算CRC表：可以根据CRC算法的多项式生成一张256行的CRC查表。
表中每一行对应一个8位字节，每行包含一个32位的CRC值。
这些预先计算的CRC值是通过不断对每个字节进行异或操作来计算出来的。
2.初始化CRC寄存器：将CRC寄存器初始化为全0。
3.逐字节计算：按照顺序读取待计算的数据流中的每个字节。
4.异或操作：将CRC寄存器中的高8位与当前读取的字节进行异或操作，并且将结果作为索引在CRC表中查找。
得到的结果是一个32位的CRC。
5.更新CRC寄存器：将CRC寄存器的高24位更新为从CRC表中查找到的32位CRC值。
6.继续计算：如果数据流还没有结束，重复步骤3至5，直到处理完所有字节。
7.计算结果：最后得到的CRC寄存器中的值就是校验结果，可以将其附加到数据中进行传输。
通过使用查表法的并行计算，可以加快CRC的计算速度。
因为预先计算CRC表的过程只需要进行一次，在后续的计算中只需要进行查表和异或操作，而不需要再进行CRC算法的计算。
此外，还有一些其他的CRC并行计算方法，如使用移位寄存器进行计算等。
这些方法根据具体的场景和需求选择使用。
总之，CRC并行计算的关键是预先计算CRC表并将结果存储起来，然后根据输入的数据进行查表和异或操作，通过并行计算的方式加速CRC的计算过程。
crc查表法计算实例
CRC（循环冗余校验）是一种常用的错误检测技术，其中查表法是一种高效计算CRC 值的方法。
下面是一个使用查表法计算CRC 的示例：```pythondef crc_lookup(data, crc_table):crc = 0xFFFF # 初始CRC 值for byte in data:crc = (crc >> 8) ^ crc_table[(crc ^ byte) & 0xFF]return crcdef calculate_crc(data):crc_table = [0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF] # CRC 查表# 将数据转换为字节列表if isinstance(data, str):data = data.encode()# 计算CRCcrc = crc_lookup(data, crc_table)return crc# 示例数据data = "Hello, World!"# 计算CRCcrc_result = calculate_crc(data)print(f"CRC Result: {hex(crc_result)}")```在上面的示例中，我们定义了两个函数：`crc_lookup` 和`calculate_crc`。
`crc_lookup` 函数用于执行CRC 查表操作，接受一个数据字节列表和CRC 查表作为参数，返回计算得到的CRC 值。
`calculate_crc` 函数用于将数据转换为字节列表，并调用`crc_lookup` 函数计算CRC 值。
在示例中，我们使用了一个16 位CRC 查表，以及一个示例数据"Hello, World!"。
C#CRC8校验
public byte CRC(byte[] buffer) {
return CRC(buffer, 0, buffer.Length); }
public byte CRC(byte[] buffer, int off, int len) {
byte crc = 0; if (buffer == null) {
0,94,188,226,97,63,221,131,194,156,126,32,163,253,31,65, 157,195,33,127,252,162,64,30, 95,1,227,189,62,96,130,220, 35,125,159,193,66,28,254,160,225,191,93,3,128,222,60,98, 190,224,2,92,223,129,99,61,124,34,192,158,29,67,161,255, 70,24,250,164,39,121,155,197,132,218,56,102,229,187,89,7, 219,133,103,57,186,228,6,88,25,71,165,251,120,38,196,154, 101,59,217,135,4,90,184,230,167,249,27,69,198,152,122,36, 248,166,68,26,153,199,37,123,58,100,134,216,91,5,231,185, 140,210,48,110,237,179,81,15,78,16,242,172,47,113,147,205, 17,79,173,243,112,46,204,146,211,141,111,49,178,236,14,80, 175,241,19,77,206,144,114,44,109,51,209,143,12,82,176,238, 50,108,142,208,83,13,239,177,240,174,76,18,145,207,45,115, 202,148,118,40,171,245,23,73,8,86,180,234,105,55,213,139, 87,9,235,181,54,104,138,212,149,203, 41,119,244,170,72,22, 233,183,85,11,136,214,52,106,43,117,151,201,74,20,246,168, 116,42,200,150,21,75,169,247,182,232,10,84,215,137,107,53 };
crc16查表法使用实例
crc16查表法使用实例当进行数据通信时，为了确保数据的完整性和准确性，常常会使用校验码来校验数据的正确性。
其中，CRC（循环冗余校验）是一种常用的校验码算法。
CRC16是CRC算法的一种，它采用16位的校验码来校验数据。
下面是一个使用CRC16查表法的实例，来解释这个过程。
在该实例中，我们将使用一个包含256个16位值的查表数组来计算CRC16校验码。
1. 初始化CRC16寄存器：首先，我们需要将CRC16寄存器初始化为一个预定的值，通常是全1（0xFFFF）。
2. 计算CRC16校验码：接下来，我们需要按照以下步骤来计算CRC16校验码：- 从要校验的数据中取出第一个字节（8位）。
- 将CRC16寄存器的高8位与该字节进行异或运算。
- 通过查表得到一个16位的值，该值即为CRC16校验码寄存器的新值。
- 将CRC16寄存器更新为上一步得到的新值。
- 重复上述步骤，直到对所有字节进行了处理。
3. 最终CRC16校验码：当所有字节都处理完毕后，CRC16寄存器中的值即为最终的CRC16校验码。
4. 校验结果：在数据通信中，发送方会将计算得到的CRC16校验码随数据一起发送给接收方。
接收方在收到数据后，同样使用CRC16查表法来计算校验码。
然后，接收方将计算得到的校验码与发送方提供的校验码进行比较，如果两个值相同，表示数据没有错误；如果不同，则表示数据存在错误。
总结：CRC16查表法是一种高效的计算CRC16校验码的方法。
它通过使用一个查表数组来加快计算过程，从而提高了效率。
该方法的实现步骤较为简单，只需要按照特定的顺序对数据进行处理，并使用查表数组来获取校验码的新值。
通过比较接收方计算得到的校验码与发送方提供的校验码，可以判断数据是否正确。
因此，CRC16查表法被广泛应用于数据通信中，以确保数据的完整性和准确性。
modbus crc 查表法与计算法
Modbus是一种用于串行通信的协议，通常用于工业控制系统中的设备之间的通信。
在Modbus协议中，通信的数据经常需要进行CRC （循环冗余校验）校验以确保数据的准确性。
在实际应用中，我们可以通过查表法或计算法来计算Modbus协议中的CRC校验值。
本文将介绍Modbus CRC的查表法和计算法，并对这两种方法进行比较和分析。
一、Modbus CRC的概念及应用Modbus通信协议是一种用于工业控制系统的通信协议，它规定了设备之间的数据通信格式和规则。
在Modbus协议中，通信的数据需要进行CRC校验以确保数据的完整性和准确性。
CRC校验是一种通过对数据进行处理得到固定长度的校验码，用于校验数据传输的正确性的技术。
Modbus协议中的CRC校验值通常是16位的，可以通过CRC计算器进行计算，并将计算得到的校验值附加到数据传输中。
接收端收到数据后，同样可以通过计算CRC校验值来验证数据的正确性。
二、Modbus CRC的查表法1. 查表法是一种通过预先计算出CRC校验值并存储在表中，然后在实际使用时直接查表得到CRC校验值的方法。
对于Modbus协议中的CRC校验，可以使用一个256个元素的查表来进行计算。
2. 查表法的优点是计算速度快，适用于嵌入式系统或资源有限的设备。
由于CRC校验是通过查表得到的，因此不需要进行复杂的计算，可以节省系统资源和计算时间。
3. 但是查表法的缺点是需要额外的存储空间来存储CRC校验值的查表，对于一些资源有限的设备可能会造成存储空间的浪费。
三、Modbus CRC的计算法1. 计算法是一种通过数学计算来得到CRC校验值的方法。
对于Modbus协议中的CRC校验，可以使用多项式除法来进行计算。
2. 计算法的优点是不需要额外的存储空间来存储查表，因此不会造成存储空间的浪费。
而且计算法可以适用于任何系统，不受资源限制的影响。
3. 但是计算法的缺点是计算速度相对较慢，特别是对于资源有限的嵌入式系统或单片机来说，可能会影响系统的性能。
c语言crc校验程序查表法
c语言crc校验程序查表法
（原创版）
目录
1.CRC 校验原理
2.C 语言 CRC 校验程序实现
3.查表法在 CRC 校验中的应用
4.实例：使用查表法实现 CRC 校验
正文
一、CRC 校验原理
CRC（Cyclic Redundancy Check，循环冗余校验）是一种基于二进制多项式的数据校验技术。
它通过在数据末尾附加一些校验位，然后接收方在接收到数据后，通过相同的计算方法，对数据进行校验，以判断数据在传输过程中是否发生了改变或损坏。
CRC 校验的主要优点是能够检测出大部分数据传输错误，且计算简单，易于实现。
二、C 语言 CRC 校验程序实现
C 语言中实现 CRC 校验的主要步骤如下：
1.首先，根据需要生成一个二进制多项式。
这个多项式可以是固定的，也可以是随机生成的。
2.将待校验的数据用二进制表示，并在数据末尾添加一些校验位，使得整个数据长度可以被二进制多项式整除。
3.使用二进制多项式去除数据，得到一个余数。
这个余数就是 CRC 校验的结果。
4.在接收端，使用相同的方法计算 CRC 校验结果，然后将其与发送端得到的结果进行比较。
如果二者相同，则认为数据传输正确；如果不同，
则认为数据发生了改变或损坏。
三、查表法在 CRC 校验中的应用
查表法是一种常用的 CRC 校验算法。
它通过预先计算一组 CRC 值，并将其存储在表格中。
在需要进行 CRC 校验时，只需要查找对应的 CRC 值即可。
这种方法的优点是计算速度快，节省存储空间。
crc16查表法中表格数据计算方法及实例
最近在搞CRC校验，用的是CRC16标准，查看了很多资料发现很多讲的都是CRC16-CCITT标准，一直想弄明白CRC-16标准中的采用查表法的方式中那两个表格中的数是如何求出来的。
可惜没有一个文章仔细的讲，更没有文章给出实例来算一算。
一切只能靠自己了，谁让我喜欢寻根摸底呢。
研究了一下本站会员玉丫子的文章，自己琢磨了琢磨，终于知道是怎么算出来的了。
CRC16算法的生成多项式x^16 + x^15 + x^2 + 1，十六进制表示为0x8005。
CRC16常见的表格中的数据是按照先传输LSB，消息右移进寄存器来计算的。
因此需要判断寄存器的最低位LSB，同时要将0x8005按位颠倒后(0xA001)根据LSB的情况决定是否与寄存器异或即可。
CRC16的表格中对应的数依次为0~255计算出来的CRC值，因此，此处只选取其中一两个数作为实例计算CRC值。
具体步骤如下所示：1)从0~255中选取需要计算的数，将其对应的十六进制数放入一个长度为16的寄存器的低八位，高八位填充0；2)如果寄存器的末位LSB为1，将寄存器的数值右移1位，再与0xA001位异或，否则仅将寄存器右移1位；3)重复第2步，直到低八位全部右移出寄存器；4)寄存器中的值则为校验码。
从0~255中挑选2（对应0x02）计算其CRC值：0x02的CRC-16的表格计算（反向）00000000 00000010 <- 最低位LSB = 0，高八位填充000000000 000000010 右移,高位填充0，并舍弃最后一位----------------- 第一次计算00000000 00000001 <- LSB = 100000000 000000001 右移,舍弃最后一位^10100000 00000001 <-与0xA001异或----------------- 第二次10100000 00000001 <- LSB = 101010000 000000001右移,舍弃最后一位^10100000 00000001 <-与0xA001异或----------------- 第三次11110000 00000001 <- LSB = 101111000 000000001右移,舍弃最后一位^10100000 00000001 <-与0xA001异或----------------- 第四次11011000 00000001 <- LSB = 101101100 000000001右移,舍弃最后一位^10100000 00000001 <-与0xA001异或----------------- 第五次11001100 00000001 <- LSB = 101100110 000000001右移,舍弃最后一位^10100000 00000001 <-与0xA001异或----------------- 第六次11000110 00000001 <- LSB = 101100011 000000001右移,舍弃最后一位^10100000 00000001 <-与0xA001异或----------------- 第七次11000011 00000001 <- LSB = 101100001 100000001右移,舍弃最后一位^10100000 00000001 <-与0xA001异或----------------- 一共右移了八次，得到的结果为CRC11000001 10000001 <- CRC: 0xC1 81从本文最后的附表中可以看出auchCRCHi[]的第三个值就是0x 81，auchCRCLo[]的第三个值就是0xC1,可见计算无误。
CRC16计算方法
CRC-16校验码计算方法
常用查表法和计算法。
计算方法一般都是：
（1）、预置1个16位的寄存器为十六进制FFFF（即全为1），称此寄存器为CRC 寄存器；
（2）、把第一个8位二进制数据（既通讯信息帧的第一个字节）与16位的CRC 寄存器的低
8位相异或，把结果放于CRC寄存器，高八位数据不变；
（3）、把CRC寄存器的内容右移一位（朝低位）用0填补最高位，并检查右移后的移出位；
（4）、如果移出位为0：重复第3步（再次右移一位）；如果移出位为1，CRC 寄存器与多
项式A001（1010 0000 0000 0001）进行异或；
（5）、重复步骤3和4，直到右移8次，这样整个8位数据全部进行了处理；（6）、重复步骤2到步骤5，进行通讯信息帧下一个字节的处理；
（7）、将该通讯信息帧所有字节按上述步骤计算完成后，得到的16位CRC寄存器的高、低字节进行交换；
（8）、最后得到的CRC寄存器内容即为：CRC码。
以上计算步骤中的多项式A001是8005按位颠倒后的结果。
查表法是将移位异或的计算结果做成了一个表，就是将0~256放入一个长度为16位的寄存器中的低八位，高八位填充0，然后将该寄存器与多项式0XA001按照上述3、4步骤，直到八位全部移出，最后寄存器中的值就是表格中的数据，高八位、低八位分别单独一个表。
16bit crc 查表法
16bit crc 查表法16位CRC查表法是一种常用的校验码算法，它通过查表的方式来快速计算数据的校验码。
本文将介绍16位CRC查表法的原理和应用。
一、什么是CRC校验码CRC（Cyclic Redundancy Check）是一种校验码，用于检测数据传输或存储过程中的错误。
它通过对数据进行特定运算，生成一串固定长度的校验码，用于校验数据是否发生错误。
CRC校验码广泛应用于网络传输、存储介质等领域。
二、16位CRC查表法原理CRC查表法是一种基于查表的计算方法，它通过预先生成一张CRC 表，将每个可能的输入值对应的校验码存储在表中。
当需要计算CRC校验码时，直接通过查表来获取。
16位CRC查表法的具体步骤如下：1. 初始化CRC寄存器为0xFFFF。
2. 依次处理每个输入字节，将其与CRC寄存器的低8位进行异或运算。
3. 将CRC寄存器的值作为查表的索引，从CRC表中取出对应的16位值。
4. 将CRC寄存器右移8位，再将上一步取出的值与CRC寄存器的低8位进行异或运算。
5. 重复第3步和第4步，直到处理完所有的输入字节。
6. 最后，将CRC寄存器的值取反，得到最终的16位CRC校验码。
三、16位CRC查表法的优势16位CRC查表法相比于其他计算方法有以下优势：1. 高效快速：通过查表的方式，避免了复杂的计算过程，大大提高了计算效率。
2. 易于实现：CRC查表法的实现相对简单，适用于各种硬件平台和编程语言。
3. 占用空间小：CRC表的大小只需要2^16个16位值，相对于直接计算CRC校验码的方法更节省存储空间。
四、16位CRC查表法的应用16位CRC查表法在实际应用中有广泛的应用，包括但不限于以下领域：1. 数据通信：在网络通信中，发送方将数据计算CRC校验码并附加在数据包中，接收方通过计算接收到的数据的CRC校验码来验证数据的完整性。
2. 存储介质：在磁盘、光盘等存储介质中，CRC校验码用于检测数据读取过程中的错误，并进行纠错。
crc16校验查表法原理
crc16校验查表法原理CRC16校验是一种常用的循环冗余校验算法，用于验证数据在传输过程中是否发生了错误或损坏。
CRC16校验的查表法原理是通过预先计算并存储一个256个元素的查表表格，通过查表的方式来计算校验值，提高计算效率。
CRC16校验的原理是将待校验的数据按照一定的规则进行计算，生成一个校验值。
这个校验值可以用来验证数据的完整性，如果校验值与接收方计算得到的校验值一致，那么可以认为数据传输是正确的。
我们来看一下CRC16校验的计算过程。
假设待校验的数据为D，校验值为CRC。
CRC的初始值设为0xFFFF。
校验过程中，将D的每个字节与CRC的低8位进行异或运算，得到一个新的CRC值。
然后，将CRC右移8位，并与一个预先定义的多项式进行异或运算。
重复这个过程，直到对D的每个字节都进行了异或运算。
最后，得到的CRC值就是校验结果。
为了提高计算效率，CRC16校验算法使用了查表法。
查表法的基本思想是在计算过程中，通过查表的方式快速地得到CRC的更新值。
具体来说，算法预先计算并存储了一个256个元素的查表表格，表格中每个元素都是一个16位的值。
校验过程中，将D的每个字节作为表格的索引，从表格中取得对应的16位值，然后与CRC进行异或运算，得到一个新的CRC值。
重复这个过程，直到对D的每个字节都进行了异或运算。
最后得到的CRC值就是校验结果。
查表法的优势在于，通过预先计算并存储查表表格，可以避免重复计算。
在校验过程中，只需要根据D的每个字节从表格中查找对应的值，然后进行异或运算，从而大大提高了计算效率。
为了更好地理解CRC16校验的查表法原理，下面举一个简单的例子来说明。
假设待校验的数据为0x12345678，校验值为0xFFFF。
首先，根据这个数据计算CRC值。
根据查表法原理，我们可以预先计算并存储一个256个元素的查表表格，表格中的每个元素都是一个16位的值。
下面是一个简化的查表表格：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,...根据查表法原理，我们将0x12345678的每个字节作为表格的索引，从表格中查找对应的16位值，并与CRC进行异或运算。
CRC8CRC16CRC32查表法中表中元素是如何计算得到？
CRC8CRC16CRC32查表法中表中元素是如何计算得到？CRC8/CRC16/CRC32查表法中表中元素是如何计算得到？const char CRC8Table[]={0, 94, 188, 226, 97, 63, 221, 131, 194, 156, 126, 32, 163, 253, 31, 65,157, 195, 33, 127, 252, 162, 64, 30, 95, 1, 227, 189, 62, 96, 130, 220,35, 125, 159, 193, 66, 28, 254, 160, 225, 191, 93, 3, 128, 222, 60, 98,190, 224, 2, 92, 223, 129, 99, 61, 124, 34, 192, 158, 29, 67, 161, 255,70, 24, 250, 164, 39, 121, 155, 197, 132, 218, 56, 102, 229, 187, 89, 7,219, 133, 103, 57, 186, 228, 6, 88, 25, 71, 165, 251, 120, 38, 196, 154,101, 59, 217, 135, 4, 90, 184, 230, 167, 249, 27, 69, 198, 152, 122, 36,248, 166, 68, 26, 153, 199, 37, 123, 58, 100, 134, 216, 91, 5, 231, 185,140, 210, 48, 110, 237, 179, 81, 15, 78, 16, 242, 172, 47, 113, 147, 205,17, 79, 173, 243, 112, 46, 204, 146, 211, 141, 111, 49, 178, 236, 14, 80,175, 241, 19, 77, 206, 144, 114, 44, 109, 51, 209, 143, 12, 82, 176, 238,50, 108, 142, 208, 83, 13, 239, 177, 240, 174, 76, 18, 145, 207, 45, 115,202, 148, 118, 40, 171, 245, 23, 73, 8, 86, 180, 234, 105, 55, 213, 139,87, 9, 235, 181, 54, 104, 138, 212, 149, 203, 41, 119, 244, 170, 72, 22,233, 183, 85, 11, 136, 214, 52, 106, 43, 117, 151, 201, 74, 20, 246, 168,116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53}; 上⾯这个庞⼤的数组是根据，CRC8的多项式X^8+X^5+X^4+X^0 计算出来的，但该数组到底是如何被计算出来的？如果以后想换⼀个多项式时要怎么办？这就需要我们理解CRC表的计算原理了。
三种常用的CRC16校验算法的C51程序的优化
};
union{
unsigned char c[2];
unsigned int x;
}data crc;
unsigned char t;
crc.x =0;
while(len!=0) {
t = (crc.c[0]>>4) ^ (*ptr >>4);
crc.c[1] ^=crcl[t];
ptr++;
len--;
}
return crc.x;
}
优化前后的代码长度分别为1ห้องสมุดไป่ตู้5字节和146字节（包括了32字节的表格空间）。
代码测试：仅代码长度变短是不够的，衡量优化后的程序一个重要的标准是看优化前后两个函数执行相同的计算量使用的时间，或者说执行的效率是否提高了。如果优化后的函数需要时间少，就说明我们优化后的函数确实提高了效率，否则就是反而降低了程序的效率，优化失败。我在 Keil C51 下编写了一个测试程序，在程序中调用了上面的六个函数，共同计算一个长度为200字节的CRC校验，并记录下每个函数使用的时间。测试方法为：使用 Keil C51 的软件仿真功能（采用带计时功能的硬件仿真器也可以），在每个函数上加上断点，记录下执行到每个断点的时间，然后前后相减就得出每个函数的执行时间。仿真时使用的单片机型号为AT89C51，晶体频率为12MHz。
三种常用的CRC16校验算法的C51程序的优化
CRC校验又称为循环冗余校验，是数据通讯中常用的一种校验算法。它可以有效的判别出数据在传输过程中是否发生了错误，从而保障了传输的数据可靠性。
CRC校验有多种方式，如：CRC8、CRC16、CRC32等等。在实际使用中，我们经常使用CRC16校验。CRC16校验也有多种，如：1005多项式、1021多项式（CRC-ITU）等。在这里我们不讨论CRC算法是怎样产生的，而是重点落在几种算法的C51程序的优化上。
循环冗余码(crc)及计算方法
循环冗余码(crc)及计算方法循环冗余校验码，简称CRC（Cyclic Redundancy Check），是一种数据传输异常检测方法，已经被广泛应用于数据链路层和物理层等数据通信领域。
在传输过程中，所传输的信息数据可能被多次修改，或者有噪声或干扰。
这就导致了所接收到的数据并不是最初发出的特定数据，使得传输失败或受到破坏。
作为一种效果比较好的校验技术，CRC校验码技术就派上用场了，它通过数据发送者事先计算出一串特定长度（字节）的校验码放入发送的数据帧中，接收者收到数据帧时会对数据帧进行检测，以查看接收的数据帧校验码与数据是否原来发出数据时相同，如果不同，就表示数据帧损坏，接收者通知发送者重发。
CRC校验码单元通过将发出方所发送的原始数据（数据帧data）与一个固定长度的多项式（CRC多项式）按位依次做按位异或的运算，来生成新的检验码，称之为CRC校验码（check）。
如果接收res方收到了与发送snd方发出的数据帧内容相同的数据帧，那么接收res方也可以使用CRC多项式对收到的数据帧做相同的计算，如果生成的CRC校验码与原始数据帧中存储的CRC校验码相同，说明数据接收是无误的。
如果不一致，说明中间可能发生了数据传输错误，数据接收存在错误，这可能是由于传输和接收途经的环境中有噪声或是由于数据本身的丢失/"随机"改变或添加其他数据导致的。
CRC校验码的计算方法通常有两种，查表法和无查表法。
查表法即在发送前定义好一张查表，根据查表给出CRC-Code。
无查表法是一种比较复杂的算法，该法首先根据CRC多项式，将多项式拆解成一个个单项式数及其系数，然后，根据定义式进行模2加，一直进行运算，得出最后的CRC校验值，该校验值就作为原来数据在发送前附加上去。
CRC校验码是目前数据链路层较为安全的一种编码技术，它可以在较大的概率内检测出传输中的比特错误。
而且，CRC校验的编码效率高，而且相当安全，是一种能够在低价值硬件中实现的有效的编码和校验技术。
crc16余式查表法对应的多项式公式
标题：CRC16余式查表法对应的多项式公式目录1. 什么是CRC16余式查表法2. CRC16余式查表法的原理3. CRC16余式查表法所对应的多项式公式4. CRC16余式查表法的应用5. 结论正文1. 什么是CRC16余式查表法CRC（Cyclic Redundancy Check）循环冗余校验是一种常用的数据校验方法，用于检测数据传输或存储过程中出现的错误。
CRC16是一种16位的循环冗余校验算法，它通过对待校验数据进行预先约定的除法运算来生成校验码。
在实际应用中，可以使用不同的生成多项式来对数据进行校验，其中CRC16余式查表法就是一种常见的实现方式。
2. CRC16余式查表法的原理CRC16余式查表法的核心思想是利用一个预先生成的查表来快速计算数据的校验码。
具体来说，它首先需要一个预先生成的256个16位二进制数的查表，对于每个8位的输入数据字节，它将根据这个字节的值从查表中找到对应的16位余式，并将其与之前的余式进行异或计算，得到新的余式。
通过重复这个过程直到所有数据字节都被处理完毕，最终生成的余式就是数据的CRC16校验码。
3. CRC16余式查表法所对应的多项式公式CRC16余式查表法对应的多项式公式可以用如下形式表示：G(x) = x^16 + x^15 + x^2 + 1其中，G(x)是一个16位的多项式，它对应了CRC16的生成多项式。
在实际计算中，可以直接利用这个多项式来进行CRC16的计算，而不需要每次都对16位的二进制数进行除法运算。
这样就大大提高了计算的效率，特别是对于嵌入式系统等资源受限的环境来说，CRC16余式查表法提供了一种高效的数据校验算法。
4. CRC16余式查表法的应用CRC16余式查表法广泛应用于数据通信、存储和传输的领域。
由于它计算效率高、实现简单且不依赖除法运算，因此被广泛应用在各种需要数据校验的场景中，如网络通信协议（如Modbus、Profibus等）、文件传输（如ZMODEM协议、XMODEM协议等）以及存储介质（如磁盘、闪存等）等。
8位crc和16crc 查表法
8位crc和16crc 查表法CRC（Cyclic Redundancy Check）是一种循环冗余校验码，用于检测数据传输中的错误。
它通过给数据附加一个校验值来进行操作，以便在接收端能够验证数据的准确性。
本文将介绍8位CRC和16位CRC的查表法。
查表法是一种计算CRC的有效方法，它通过预先计算存储在查表中的校验值来加快计算速度。
8位CRC和16位CRC的查表法都是基于这种思想实现的。
首先，我们来介绍8位CRC的查表法。
8位CRC的查表法需要预先生成一个256长度的查表数组。
该数组的每个元素都是一个8位的校验值。
生成查表数组的方法如下：1.初始化CRC寄存器为全1。
2.对每个可能的8位输入值进行循环：a.将输入值与CRC寄存器进行异或操作。
b.对CRC寄存器进行8次右移操作。
3.根据CRC寄存器的最终值，将对应输入值的校验值存储在查表数组中。
生成查表数组后，我们可以使用该数组对数据进行CRC计算。
计算方法如下：1.初始化CRC寄存器为全1。
2.对每个输入字节进行循环：a.将当前输入字节与CRC寄存器进行异或操作，得到查表数组的索引。
b.根据索引从查表数组中取出对应的校验值。
c.将CRC寄存器与校验值进行异或操作。
d.对CRC寄存器进行8次右移操作。
3.根据CRC寄存器的最终值得到计算得到的校验值。
接下来，我们来介绍16位CRC的查表法。
与8位CRC类似，16位CRC的查表法也需要预先生成一个65536长度的查表数组。
生成查表数组的方法如下：1.初始化CRC寄存器为全1。
2.对每个可能的16位输入值进行循环：a.将输入值与CRC寄存器进行异或操作。
b.对CRC寄存器进行16次右移操作。
3.根据CRC寄存器的最终值，将对应输入值的校验值存储在查表数组中。
生成查表数组后，我们可以使用该数组对数据进行CRC计算。
计算方法如下：1.初始化CRC寄存器为全1。
2.对每个输入字节进行循环：a.将当前输入字节与CRC寄存器进行异或操作，得到查表数组的索引。
CRC(查表法)-表的由来
CRC(查表)-表的由来bylenglx(*************,*************************)2006/07/251)硬件电路组成a) x^16 + x^12 + x^5 + 1┌───────────┬─────────────────┬─────────────┐↑┌─┬─┬─┬─┐↓┌─┬─┬─┬─┬─┬─┬─┐↓┌─┬─┬─┬─┬─┐│◎←│15│14│13│12│←◎←│11│10│09│08│07│06│05│←◎←│04│03│02│01│00│←┘↑└─┴─┴─┴─┘└─┴─┴─┴─┴─┴─┴─┘└─┴─┴─┴─┴─┘inb) x^8 + x^2 + x + 1┌───────────────┬─────┬─────┐↑┌─┬─┬─┬─┬─┬─┐↓┌─┐↓┌─┐│◎←│07│06│05│04│03│02│←◎←│01│←◎←│00│←┘↑└─┴─┴─┴─┴─┴─┘└─┘└─┘in2) 简单算法模型(按bit计算)照以上的硬件电路来看,其工作原理就是:如果原来CRC的最高位异或输入是1的话,那么絇OST/club/bbs/SaveOwnerEd?并且异或生成多项式(图a为0x1021,图b为0x7).如果原来CRC的最高位异或输入是高位异或输入是0的话,那么结果就是CRC左移一位.那么可以得到以下的程序(以图a例)U16 crc_cal(bit * in, U32 cnt){U16 crc = 0;while(cnt--){bool tmp = (crc >> 15) ^ *in;crc <<= 1;if(tmp)crc ^= 0x1021;in ++;}return crc;}3) 查表(按字节计算)很显然,按比特计算的方法,其效率是低下的.下面介绍查表方法(按字节计算).要知道为什么可以用查表的方法,需要一些预备知识.以图b为例,假设当前的CRC值是1011 1001,现在要输入4比特数据1101,其生成多项式是:0000 0111CRC = 1011 1001, in=1101 , G(X)= 0000 0111<计算方法1> <计算方法2>step: 1011 1001 0110 10011: 011 1001 0 110 1001 02: 11 1001 00 10 1001 00^ 00 0001 11 ^00 0001 11 <1>-------------- --------------11 1000 11 10 1000 113: 1 1000 110 0 1000 110^ 0 0000 111 ^0 0000 111 <2>---------------- -------------1 1000 001 0 1000 0014: 1000 0010 1000 0010<计算方法1>是硬件电路的完全模拟算法step 1: 将crc左移一位,因为crc的最高位是1,输入也是1,所以不做处理.step 2: 将crc左移一位,因为crc的最高位是0,输入是1,所以还需要异或G(X).....step 4: 将crc左移一位,因为crc的最高位是0,输入也是0,所以不做处理.得到最终的结果 crc = 1000 0010实际上,在crc左移以后,是否还要异或生成多项式的条件是: crc的最高位和输入位异或后的值.那么是否可以预先将CRC(h)的值与要输入的4比特数据异或,作为是否判断条件呢.答案是肯定的. CRC = 1011 1001, in=1101, CRC(h)^in = 0110其计算过程见<计算方法2>step 1: 将CRC左移一位,因为CRC的最高位是0,所以不做处理.step 2: 将CRC左移一位,因为CRC的最高位是1,所以还需要异或G(X).....step 4: 将CRC左移一位,因为CRC的最高位是0,所以不做处理.得到最终的结果 CRC = 1000 0010虽然,上面的结果是一样的,可有证据证明无论什么情况下,结果都是对的?静下来想想,你就是知道这2个方法确实能得出相同的结果.当4比特的输入完成之后,整个CRC值左移了4位,原来的CRC(h)只是作为判断异或生成多项式的条件存在过.最终的CRC值完全是G(X)和CRC(l)不停地(异或/移位)的结果.虽然,在CRC计算的过程中,CRC不停的在变化着,但:1. 如果在<方法1>中,由于CRC的最高位和输入异或后的结果等于0,那么CRC只是左移一位.显然2个方法是一样的.2. 如果在<方法1>中,由于CRC的最高位和输入异或后的结果等于1,那么CRC左移一位后,还需要异或G(X).异或G(X)的过程中,可能使CRC的后续某位产生变化(也可能不变化,视生成多项式的值而定).a.如果没发生变化,那当这位最后移到最高位,作为判断条件的时候,仍然是以前的这个值和输入位的异或.显然2个计算方法是一样的.b.如果变化过, 那当这位最后移到最高位,作为判断条件的时候,是变化过后的值和输入位的异或.但如果<方法1>能引起后续某位的变化,<方法2>同样也会引起同一位的变化.这样当这位最后移到最高位,作为判断条件的时候,2种方法的判断条件仍然是一致的.* 关于这部分,我描述得不怎么清楚,那是因为我小时候地语文基础没打好,:).如果你有更好地描述,请告诉我.好了,预备知识完毕,现在开始探讨那个查找表是怎么来的.请看<方法2>,最终的CRC的结果是: (CRC(l) << 4) ^ <1> ^ <2><计算方法2>CRC = 1011 1001, in=1101 , G(X)= 0000 0111|-----------------------> CRC(h)^in = 1011 ^ 1101 = 0110|| |------------------> CRC(l)---- ----0110 1001110 1001 010 1001 00^00 0001 11 <1>--------------10 1000 110 1000 110^0 0000 111 <2>-------------0 1000 0011000 0010由于异或的可结合律,其结果等同于: (CRC(l) << 4) ^ ( <1> ^ <2> )这说明, ( <1) ^ <2> )可以预先制作成表格,采用查表的方法计算CRC, 表的索引是 CRC(h) ^ in .其结果是: ( CRC(l) << 4) ^ table[ CRC(h) ^ in ].因为是4比特,表的大小是16.表的内容可以根据G(X),预先计算.这里举例用的4比特,基于字节的方法可以用同样的方法.那么现在开始编程了.U16 crc_tab[256]= {...};U16 crc_cal(U8 * ptr, U32 cnt){U16 crc = 0;U8 da;while (cnt--){da = crc >> 8; // CRC(h)crc <<= 8;crc ^= crc_tab[da ^ *ptr++];}return crc;}既然你已经知道了查表的原理,那么编一个计算表值的程序不成问题了.#define GX 0x1021void CCrcDlg::OnButton1(){WORD table[256];for(int i =0; i<256; i++){WORD crc = i << 8;for(int n=0; n<8; n++){bool tmp = crc & (1<<15) ? true : false;crc <<= 1;if(tmp)crc ^= GX;}table = crc;}}那么你得到了这么个表:U16 table[256]={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, 0XB7F A, 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};---------------------------------- END ------------------------------------。
c语言 crc 查表算法
c语言crc 查表算法在C语言中，可以使用查表法实现CRC校验算法。
以下是一个简单的示例代码：c复制代码#include<stdio.h>#include<stdint.h>#define POLY 0x1021 // CRC多项式#define WIDTH 8 // CRC位数#define TABLE_SIZE (1 << WIDTH)uint8_t crc_table[TABLE_SIZE];void init_crc_table() {for (int i = 0; i < TABLE_SIZE; i++) {uint8_t crc = i;for (int j = 0; j < WIDTH; j++) {if (crc & 1) {crc = (crc >> 1) ^ POLY;} else {crc >>= 1;}}crc_table[i] = crc;}}uint8_t crc(uint8_t data[], int len) {uint8_t crc = 0;for (int i = 0; i < len; i++) {crc = crc_table[(crc ^ data[i]) & 0xFF];}return crc;}int main() {init_crc_table(); // 初始化CRC表uint8_t data[] = {0x01, 0x02, 0x03, 0x04};uint8_t crc_result = crc(data, sizeof(data)); // 计算CRC校验码printf("CRC result: %02X\n", crc_result); // 输出结果return0;}在这个示例中，我们定义了一个crc_table数组，用于存储CRC多项式的值。
查表法计算CRC
在硬件实现中，CRC 通常采用线性反馈移位寄存器实现。
其中一个单元对应CRC 的每一比特，图3-2给出了8比特寄存器。
对于移位寄存器中的每一单元，如果在发生器多项式中D 的某次幂为1，那么到下一个单元的连接要经过一个异或门(XOR)。
对于每一传输块，首先将移位寄存器置零；接传输块数据输入移位寄存器，当传输块的所有比特全部输入移位寄存器后，移位寄存器的存储内容就是所要求的CRC 比特。
这些比特以倒序传输，如图3-2，首先传输在最左寄存器中的CRC 比特。
图3-2 8比特CRC 生成移位寄存器对于上述算法，当输入1个比特时，要经过一系列的异或和移位，才能完成。
上图只是8比特CRC 的实现图，考虑到g CRC24A (D)的多项式，实现更为复杂。
而下行峰值速率又相对很高，采用这种方法显然是达不到需求的速率的。
下面介绍一种更为高效的查表法[17]，多核DSP 计算CRC 也使用了查表法。
设传输块有k 比特，CRC 比特数为k n -；下面是按4比特查表计算24比特CRC 的过程。
对于传输块中的二进制序列，可以用下面的多项式表示：()1011222k k k k m x m m m m --=++++ 式(3-1) 将上式每4个比特组合在一起，如下所示：()44(1)4011222n n n n m x m m m m --=++++ 式(3-2)求此序列的24比特CRC 时，先乘以242（左移24位）后，再除以CRC 的生成多项式()x g ，所得到的余数即为所求的CRC 码。
如下式所示：()()()()()2424242444(1)01222222n n n m x m m m g x g x g x g x -=+++式(3-3) 设：()()()()240002r x m Q x g x g x =+，其中()0r x 为24位二进制余数；将它代入式(3-3)可得：()()()()()()()()()()()()242424044(1)1042424044(1)102222222222n n n nn n m x r x m m Q x g x g x g x g x r x m m Q x g x g x g x --⎡⎤=++++⎢⎥⎣⎦⎧⎫⎪⎪=++++⎨⎬⎪⎪⎩⎭式(3-4)因为，()()()()()4204244000002[2]222h l h l r x r x r x r x r x =+=+ 式(3-5)其中()0h r x 是()0r x 的高4位，()0l r x 是()0r x 的低20位。
crc查表法计算实例
crc查表法计算实例CRC查表法计算实例什么是CRC查表法CRC (Cyclic Redundancy Check) 是一种校验算法，常用于网络通信、数据存储等领域，用于检测数据在传输过程中是否发生错误。
CRC查表法是一种高效的计算CRC的方法，通过提前生成一个CRC校验表，能够大幅加快CRC的计算速度。
CRC查表法的原理CRC查表法的原理是通过一个CRC校验表来进行CRC的计算，而不是像传统的Bit-by-Bit方式一位一位地计算。
CRC校验表是预先计算好的，根据CRC算法的不同，表的大小也有所不同。
计算CRC时，只需要将数据按字节与CRC校验表进行查表，最后得到的结果即为CRC 值。
CRC查表法的步骤CRC查表法的计算步骤如下：1.初始化CRC校验值为特定的初始值。
2.将第一个字节与CRC校验表进行查找，得到对应的新的CRC校验值。
3.重复步骤2，将后续的字节与CRC校验表进行查找，并更新CRC校验值。
4.最后得到的CRC校验值即为计算结果。
CRC查表法计算实例假设需要计算一个16位CRC校验值，初始值为0xFFFF，数据为0x。
计算过程如下：1.初始化CRC校验值为0xFFFF。
2.将第一个字节0x12与CRC校验表进行查找，得到新的CRC校验值为0x6F87。
3.继续查表操作，将后续字节0x34、0x56、0x78依次与CRC校验表进行查找，并更新CRC校验值。
4.最后得到的CRC校验值为0xAEE7，即为计算结果。
通过CRC查表法，只需要对每个字节进行一次查找操作，计算速度较快，尤其对于大量数据的CRC校验非常高效。
总结CRC查表法通过预先生成CRC校验表，大大加快了CRC的计算速度。
它是一种高效可靠的校验算法，被广泛应用于各个领域。
对于创作者来说，了解CRC查表法的原理和步骤，能够更好地理解和运用CRC 校验算法，提高代码的效率和可靠性。
CRC查表法的优势CRC查表法相较于传统的Bit-by-Bit方式，具有以下几个优势：1.计算速度更快：使用CRC查表法，只需要进行查表操作，而不是逐位计算。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
}
return ((chCRCHi << 8) | chCRCLo) ;
}
unsigned char data[9]={0x01, 0x10 ,0x00, 0x40 ,0x00, 0x01 ,0x02 ,0x07, 0xD0}; #define length 9 unsigned char *p[length]; void main() {
CRC16=*ptr^CRC16; for (j=0;j< 8;j++) {
tmp=CRC16 & 0x0001; CRC16 =CRC16 >>1; if (tmp) CRC16=CRC16 ^ 0xa001; } *ptr++; } return(CRC16); } void main() { for(j=0;j<10;j++) { p[j]=&data[j]; } CRC=crc16l(*p,length);
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,
int CRC=0; int j=0; for(j=0;j<10;j++) {
p[j]=&data[j]; }
CRC=CRC16_1(*p,length);
printf("CRC=%x\n",CRC);
}
*/
typedef unsigned char uchar;
typedef unsigned int
uint;
typedef unsigned short
uInt16;
uint CRC;
uint j;
uchar data[9]={0x01, 0x10 ,0x00, 0x40 ,0x00, 0x01 ,0x02 ,0x07, 0xD0};
#define length 9
uchar *p[length];
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,
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
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,
};
unsigned char chCRCLTalbe[] =
// CRC 低位字节值
表
{
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7,
CRC查表法+计算法.txt
#include"stdio.h"
/*
unsigned char 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,
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,
};
unsigned int CRC16_1(unsigned char *pchMsg, unsigned int wDataLen) 第1页
CRC查表法+计算法.txt
{
unsigned char chCRCHi = 0xFF; // 高CRC字节初始化
unsigned char chCRCLo = 0xFF; // 低CRC字节初始化
unsigned char wIndex;
// CRC循-)
{
// 计算CRC
wIndex = chCRCLo ^ *pchMsg++ ;
chCRCLo = chCRCHi ^ chCRCHTalbe[wIndex];
chCRCHi = chCRCLTalbe[wIndex] ;
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,
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,
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, 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,