CRC 原理

已于 2024-05-24 10:00:54 修改
阅读量949 收藏 24
点赞数 23
分类专栏： CRC 文章标签： 编辑器 算法 c语言 linux
于 2024-03-27 16:24:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45784125/article/details/137081056
版权

文章目录

CRC实例

假设要传输的原始数据为1101011011B，发送方和接收方在通信前约定好的除数为10011B。由于除数10011B是五位数（5bit），那么假设余数（即CRC码）为四位数（4bit）。因为现在余数未知，所以在进行模二除法运算前先将余数设为0000B，即待发送的数据为11010110110000B。下面开始进行模二除法运算来确定余数（即CRC码），更多计算细节，请查询模二除法：
在这里插入图片描述
可见余数（即CRC码）为1110B，因此发送方实际发送的是11010110111110B。

总结规律

将每次的计算结果定位res，使用的多项式称为p，正常的多项式是POLY=10011，异常为0，则：

每次迭代，根据res的首位决定p，若res的首位是1，则p=POLY；若res的首位是0，则p=0， 或者跳过此次迭代，上面的例子中就是碰到0后直接跳到后面的非零位。每次计算出结果后左移一位，即丢弃最高位。

如上图所示，直接的CRC-32校验代码如下：

/******************************************************************************
 * Name:    CRC-32/MPEG-2  x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
 * Poly:    0x4C11DB7
 * Init:    0xFFFFFFF
 * Refin:   False
 * Refout:  False
 * Xorout:  0x0000000
 * Note:
 *****************************************************************************/
uint32_t crc32_mpeg_2(uint8_t *data, uint16_t length)
{
    uint8_t i;
    uint32_t crc = 0xffffffff;  // Initial value
    while(length--)
    {
        crc ^= (uint32_t)(*data++) << 24;
        {
            if ( crc & 0x80000000 )
                crc = (crc << 1) ^ 0x04C11DB7;
            else
                crc <<= 1;
        }
    }
    return crc;
}

CRC参数模型

Width：CRC码的位宽，CRC32即为32位位宽。
Poly：省略最高位的多项式，因为更利于编程实现，即移位之后不需要考虑最高位；0x4C11DB7实际为0x104C11DB7，为32+1==33位。
Init：CRC码初始值，因为原始数据可能以不同位数的0开头，所以需要设置初始值来区分；
Refin是输入逆向标志位，如果为真，表示输入数据需要先进行逆向（即按位倒序），再进行后续运算；
Refout是最后输出逆向标志位，如果为真，表示CRC码需要先进行逆向（即按位倒序），再输出；
Xorout是最后输出异或值，是输出CRC码前与其进行异或运算的数；
Check是以UTF-8字符串"123456789"（作为8位字符数组）当做输入原始数据计算出的CRC码；
Residue是以无错误码字当做输入原始数据计算出的、不进行输出异或运算的CRC码，其具体含义有待进一步考究；
Name是算法名称。

举例

原始数据：0x34，使用CRC-8/MAXIN参数模型：

POLY = 0x31 = 0011 0001(最高位1已经省略)
INIT = 0x00
XOROUT = 0x00
REFIN = TRUE
REFOUT = TRUE

实际计算过程：

  1. 原始数据 = 0x34 = 0011 0100，多项式 = 0x31 = 1 0011 0001

  2. INIT = 00，原始数据高8位和初始值进行异或运算保持不变。

  3. REFIN为TRUE，需要先对原始数据进行翻转：0011 0100 > 0010 1100

  4. 原始数据左移8位，即后面补8个0：0010 1100 0000 0000

  5. 把处理之后的数据和多项式进行模2除法，求得余数：
    原始数据：0010 1100 0000 0000 = 10 1100 0000 0000
    多项式：1 0011 0001
    模2除法取余数低8位：1111 1011

  6. 因为REFOUT为TRUE，对结果进行翻转得到最终的CRC-8值：1101 1111 = 0xDF

  7. XOROUT进行异或，1111 1011 xor 0000 0000 = 1111 1011

  8. 数据+CRC：0011 0100 1101 1111 = 34DF，相当于原始数据左移8位+余数。
    在这里插入图片描述
    在实际计算的过程中，每次异或的最高位都会丢弃，因此在实际的代码中将poly最高位省略，相应的将crc寄存器左移一位。
    得到如下的计算代码： crc = (crc << 1) ^ 0x04C11DB7

代码优化

对于如下的代码我们举个例子，对0xA3进行crc32_mpeg_2的计算

for (i = 0; i < 8; ++i)
{
    if ( crc & 0x80000000 )
        crc = (crc << 1) ^ 0x04C11DB7;
    else
        crc <<= 1;
}

在这里插入图片描述
从上述4次计算过程可以发现，影响最终结果的只有0xA3中的A与POLY（0x04C11DB7），我们可以将该计算过程进行整合：

(0xA3 << 4)(POLY<<3)(POLY<<1)

因为POLY是固定的，异或运行有结合律，我们可以根据不同的A值，将最终0xA3需要异或的数据X提前计算出来，加速运算的过程。

同样我们也可以一次处理8bit的数据，因此我们可以得到查表法的代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
 
#define POLY 0x04C11DB7
void get_table(uint32_t *table)
{
    uint32_t res;
    for(int i=0;i<256;i++)
    {
        res = (i<<24);
          
        for (int j = 0; j < 8; ++j)
        {
            if((res&(1<<31)) != 0)
            {
                res = (res<<1)^POLY;
            }
            else
            {
                res = (res<<1);
            }
        }
        table[i] = res;
    }
}
  
uint32_t crc32_mpeg_2_table(uint8_t *data,uint32_t len, uint32_t *table)
{    
    uint8_t i;
    uint32_t crc = 0xffffffff;  // Initial value
    uint8_t index;
    while(len--)
    {
        index = (crc>>24)^(*data++)&0xff;
        crc = (crc<<8)^table[index];
    }
    return crc;
}
 
 
int main()
{
    uint8_t data[10] = {0x01,0x02,0x03,0x04};
    uint32_t table[256];
    get_table(table);
    uint32_t ret = crc32_mpeg_2_table(data,4,table);
    printf("res = %x\n",ret);
}

逆运算

对于一些CRC算法，在实际运算时需要考虑原始数据的逆向与输出结果的逆向，为了实际的代码，考虑将整个运算过程逆向，例如CRC32算法的参数模型为：

  • Name: CRC-32 x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
  • Poly: 0x4C11DB7
  • Init: 0xFFFFFFFF
  • Refin: True
  • Refout: True
  • Xorout: 0xFFFFFFFF
  • Alias: CRC_32/ADCCP
  • Use: WinRAR,ect.

在实际运算时需要现将原始数据翻转，最后还需要将结果翻转，如图所示：
在这里插入图片描述
那我们在实际计算时，可以将CRC的原始值，POLY均进行翻转，计算时移位的方向也进行翻转，可以得到直接计算公式如下：

/******************************************************************************
 * Name:    CRC-32 x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
 * Poly:    0x4C11DB7
 * Init:    0xFFFFFFFF
 * Refin:   True
 * Refout:  True
 * Xorout:  0xFFFFFFFF
 * Alias:   CRC_32/ADCCP
 * Use:     WinRAR,ect.
 *****************************************************************************/
uint32_t crc32(uint8_t *data, uint16_t length)
{
    uint8_t i;
    uint32_t crc = 0xffffffff;  // Initial value
    while(length--)
    {
        crc ^= *data++;
        {
            if ( crc & 1 )
                crc = (crc >> 1) ^ 0xEDB88320;
            else
                crc >>= 1;
        }
    }
    return crc^0xFFFFFFFF;   // ~crc
 }

同样可以得到逆向的查表法的代码

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
 
#define POLY 0xEDB88320
void get_table(uint32_t *table)
{
    uint32_t res;
    for(int i=0;i<256;i++)
    {
        res = (i);
          
        for (int j = 0; j < 8; ++j)
        {
            if((res&1) != 0)
            {
                res = (res>>1)^POLY;
            }
            else
            {
                res = (res>>1);
            }
        }
        table[i] = res;
    }
}
  
uint32_t crc32_table(uint8_t *data,uint32_t len, uint32_t *table)
{    
    uint8_t i;
    uint32_t crc = 0xffffffff;  // Initial value
    uint8_t index;
    while(len--)
    {
        index = (crc^(*data++))&0xff;
        crc = (crc>>8)^table[index];
    }
    return ~crc;
}
 
 
int main()
{
    uint8_t data[10] = {0x01,0x02,0x03,0x04};
    uint32_t table[256];
    get_table(table);
    uint32_t ret = crc32_table(data,4,table);
    printf("res = %x\n",ret);
}

硬件加速

ARMV8是支持CRC32的加速的，具体运行如下指令，查看是否包含crc32属性。
cat /proc/cpuinfo

使能硬件加速

typedef  uint32_t u32;
typedef  int64_t  s64;
typedef  uint8_t  u8;
typedef  uint64_t u64;
typedef  uint16_t u16;
 
/*
*
*   ARM hardware accelerated crc32 instruction
*
*/
#define CRC32X(crc, value) __asm__("crc32x %w[c], %w[c], %x[v]":[c]"+r"(crc):[v]"r"(value))
#define CRC32W(crc, value) __asm__("crc32w %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
#define CRC32H(crc, value) __asm__("crc32h %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
#define CRC32B(crc, value) __asm__("crc32b %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
#define CRC32CX(crc, value) __asm__("crc32cx %w[c], %w[c], %x[v]":[c]"+r"(crc):[v]"r"(value))
#define CRC32CW(crc, value) __asm__("crc32cw %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
#define CRC32CH(crc, value) __asm__("crc32ch %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
#define CRC32CB(crc, value) __asm__("crc32cb %w[c], %w[c], %w[v]":[c]"+r"(crc):[v]"r"(value))
 
static u32 crc32_arm64_le_hw(const u8 *p, unsigned int len)
{
    uint32_t crc = 0xffffffff;
    s64 length = len;
 
    while ((length -= sizeof(u64)) >= 0) {
        CRC32X(crc, *((uint64_t *)p));
        p += sizeof(u64);
    }
 
    /* The following is more efficient than the straight loop */
    if (length & sizeof(u32)) {
        CRC32W(crc, *((uint32_t *)p));
        p += sizeof(u32);
    }
    if (length & sizeof(u16)) {
        CRC32H(crc, *((uint16_t *)p));
        p += sizeof(u16);
    }
    if (length & sizeof(u8))
        CRC32B(crc, *p);
 
    return ~crc;
}
 
static u32 crc32c_arm64_le_hw(u32 crc, const u8 *p, unsigned int len)
{
    s64 length = len;
 
    while ((length -= sizeof(u64)) >= 0) {
        CRC32CX(crc, *((uint64_t *)p));
        p += sizeof(u64);
    }
 
    /* The following is more efficient than the straight loop */
    if (length & sizeof(u32)) {
        CRC32CW(crc, *((uint32_t *)p));
        p += sizeof(u32);
    }
    if (length & sizeof(u16)) {
        CRC32CH(crc, *((uint16_t *)p));
        p += sizeof(u16);
    }
    if (length & sizeof(u8))
        CRC32CB(crc, *p);
 
    return ~crc;
}

说明：

x 代表 double ：__crc32cd: 一次完成8个Byte的CRC32C计算，对应crc32cx指令。

w 代表 word ：__crc32cw：一次完成4个Byte的CRC32C计算，对应crc32cw指令。

h 代表 half： __crc32ch：一次完成2个Byte的CRC32C计算，对应crc32ch指令。

b 代表 byte：__crc32cb: 一次完成1个Byte的CRC32C计算，对应crc32cb指令。

Poly 取值不一样
CRC32 ： 0x04C11DB7; its reversed form 0xEDB88320
CRC32C ：0x1EDC6F41; its reversed form 0x82F63B78

编译指令：

aarch64-linux-gnu-gcc -O2 -mcpu=generic+crc crc32_all.c -o crc32_all

or

aarch64-linux-gnu-gcc -O2 -march=armv8-a+crc crc32_all.c -o crc32_all

参考文献

https://blog.csdn.net/u012028275/article/details/112342542
https://blog.csdn.net/qq_25814297/article/details/109402108
https://blog.csdn.net/weixin_44256803/article/details/105805628
https://www.cnblogs.com/mic-chen/p/14944988.html
https://www.zangcq.com/2020/05/17/arm-crc32-%E6%8C%87%E4%BB%A4%E5%8A%A0%E9%80%9F/
常用的crc参数模型对应代码：crc-lib-c-master.zip
包含硬件加速的crc32的代码：crc32_all.c

南风知奇意
关注
  • 23
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
matlab串行crc原理,CRC32的FPGA并行实现原理及MATLAB仿真
weixin_39878688的博客
03-17 845
其实crc已经反反复复看了好多遍了，每次总是看到一半就放弃了，觉得太简单，都有现成的东西，没必要搞懂，纯属浪费时间，但是又总是如鲠在喉，一如既往的纠结……这两天终于明白了它并行实现的原理，写个总结。1 串行实现(单bit实现)crc的实现原理很简单，做二进制除法得到余数就可以了，贴一个对我理解CRC很有帮助的一篇文章我学习CRC32、CRC16、CRC原理和算法的总结(与WINRAR结果一致)这里...
【很好】我学习CRC32、CRC16、CRC原理和算法的总结(与WINRAR结果一致).pdf
10-31
"CRC 校验算法原理和实现" CRC（Cyclic Redundancy Check，循环冗余检查）是一种常用的错误检测算法，广泛应用于数据传输和存储中。CRC 的原理是通过对数据的二进制表示进行模 2 的多项式除法，得到余数作为校验值...
CRC（循环冗余校验）查表算法的代码实现
https://github.com/blingbling-110
12-27 5169
CRC（循环冗余校验）查表算法的代码实现前言准备工作查表算法的由来查表算法的基本原理模二减法（异或运算）的性质对直接计算法进行分析基本原理的推广查表算法的代码实现测试用例正式编码代码的测试仓库地址 前言 CRC基本原理、数学描述和直接计算法的编程实现请参考笔者之前的劣文： https://blog.csdn.net/weixin_44256803/article/details/105805628 本文假设读者已有以上CRC基础 各种CRC类型汇总：https://reveng.sourceforge.io
【科普向】谁都能看懂的CRC（循环冗余校验）原理
热门推荐
https://github.com/blingbling-110
04-28 3万+
CRC原理简介CRC基本原理模二运算二进制系数多项式CRC算法示例CRC算法的数学描述常用CRC版本CRC算法的编程实现 简介 循环冗余校验（Cyclic Redundancy Check， CRC）是一种根据网络数据包或计算机文件等数据产生简短固定位数校验码的一种信道编码技术，主要用来检测或校验数据传输或者保存后可能出现的错误。它是利用除法及余数的原理来作错误侦测的。 在数据传输过程中，无论传...
CRC原理
edycm的博客
06-16 504
CRC即循环冗余校验码（Cyclic Redundancy Check）：数据通信领域中最常用的一种查错校验码，其特征是信息字段和校验字段的长度可以任意选定。循环冗余检查（CRC）是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性和完整性。
循环冗余校验码CRC原理与LFSR循环码编码器原理
w0shishabi的博客
04-24 4244
文章目录1 产生原理1.1 CRC可检测的错误？1.2 CRC生成过程？1.3 接收过程？2 CRC 的计算2.1 手算2.1 在线计算器3 Verilog 实现3.1 线性反馈移位寄存器（LFSR）循环码编码3.2 Verilog代码 1 产生原理 循环冗余校验码Cyclic Redundancy Check（CRC） 简介：在发送端根据要传送的K位二进制码序列，以一定的规则产生一个校验用的r位监督码（CRC码），附在信息后面组成n=k+r位的码发出去。这种编码也叫（n,k）码。对于一个给定的（n,k）
CRC原理和实例
dragon_cdut的博客
11-11 890
CyclicRedundancyCheck循环冗余检验，是基于数据计算一组效验码，用于核对数据传输过程中是否被更改或传输错误。 算法原理 假设数据传输过程中需要发送15位的二进制信息g=101001110100001，这串二进制码可表示为代数多项式g(x) = x^14 + x^12 + x^9 + x^8 + x^7 + x^5 + 1，其中g中第k位的值，对应g(x)中x^k的系数。将...
matlab串行crc原理,matlab中CRC的函数使用
weixin_36313344的博客
03-17 217
先学习一下matlab中CRC函数。语法如下：h = crc.generator(‘Polynomial', polynomial, ‘param1', val1, etc.)再看一个例子就比较好容易理解，% Construct a CRC generator with a polynomial defined% by x^3+x+1, with zero initial states,% and...
CRC码原理详解
qq_37708525的博客
11-14 8236
某人，查阅和参考了大量博主的优质内容，总结一篇完整的CRC码详解，文字内容尽量做到最少。CRC码即循环冗余校验码（Cyclic Redundancy Check）是数据通信领域中最常用的一种查错校验码，其特征是数据字段和校验字段的长度可以任意选定。基本原理CRC码中数据总长度为n，其中原始数据长度为k，CRC校验码长度为r，即n=k+r。将原始数据（如：1110010）+CRC校验码（如：101）组成新的数据（如：1110010101），发送到接收端。其中，CRC校验码由CRC多项式。
CRC原理详解
星星的博客
03-04 1301
参考链接： https://www.cnblogs.com/esestt/archive/2007/08/09/848856.html CyclicRedundancyCheck循环冗余检验，是基于数据计算一组效验码，用于核对数据传输过程中是否被更改或传输错误。 算法原理 假设数据传输过程中需要发送15位的二进制信息g=101001110100001，这串二进制码可表示为代...
crc.rar_CRC 原理_crc
09-23
crc循环冗余检验的原理，很详细，可供学习和编程参考。
CRC_check.rar_CRC 原理_crc
09-14
CRC的检测原理，比较系统而又详细的介绍了CRC码的检测
如何理解CRC原理
01-14
一篇很容易让不懂CRC的人5分钟就理解的好总结
Unity 从0开始编写一个技能编辑器_02_Buff系统的生命周期
qq_45498613的博客
06-10 679
工作也有一年了，对技能编辑器也有了一些自己的看法，从刚接触时的惊讶，到大量工作时觉得有一些设计的冗余，在到特殊需求的修改，运行效率低时的优化，技能编辑器在我眼中已经不再是神圣不可攀的存在的，所以可以开始正式进行技能编辑器的编写工作了。 首先 无论是塔防 MOBA 还是MMO,buff机制都是不可或缺的一部分，buff可以看作是由Timer实现的一种计时器，即以时间为单位执行一些脚本事件 比如:敌方对我造成**dot**伤害(每多少秒灼烧（被作为**target释放技能**）)，buff也具有层数 我被友
【乐吾乐2D可视化组态编辑器】导出HTML，下载离线部署包
le5le_iot的博客
06-13 719
导出项目图纸的私有化部署包
Web前端编辑器：探索其深度与广度
最新发布
liyrbtqe_66w的博客
06-14 197
Web前端编辑器的插件生态是其生命力的体现。无论是用于提升编码效率的工具，还是用于实现特定功能的插件，都能让开发者的工作变得更加轻松和高效。一方面，随着人工智能和机器学习技术的应用，编辑器将变得更加智能化和自动化，为开发者提供更加精准的辅助和建议。另一方面，随着云计算和分布式技术的普及，编辑器也需要适应远程协作和分布式开发的需求，提供更为便捷的团队协作和版本控制功能。未来，随着技术的不断进步和需求的不断变化，我们有理由相信，Web前端编辑器将会变得更加智能、高效和灵活，为开发者带来更加美好的工作体验。
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 426
【代码】力扣LCP 08.剧情触发时间。
fpga实现crc原理
08-01
FPGA（现场可编程逻辑门阵列）是一种可编程的硬件设备，可以根据用户的需求进行灵活的配置和实现。CRC（循环冗余校验）是一种错误检测技术，常用于数据传输中。 FPGA实现CRC原理的基本过程包括以下几个步骤： 1. 首先，需要定义CRC的生成多项式。生成多项式是决定校验位长度和性能的关键因素。常用的生成多项式有CRC-8、CRC-16和CRC-32等。 2. 接下来，需要将生成多项式转化为二进制形式，并计算出对应的多项式系数。这些系数将会在后续的计算中被使用。 3. 然后，在FPGA中创建一个数据位宽与生成多项式位数相等的寄存器。该寄存器将用于存储待校验的数据。 4. 将数据与生成多项式进行异或运算，并将结果暂存在一个寄存器中。然后，将该结果右移一位，再次进行异或运算。重复这个过程，直到将所有的数据位都处理完毕。 5. 循环冗余校验码即为最后的寄存器内容。将该校验码与数据一起传输，接收方可通过相同的生成多项式和计算过程进行校验，并判断数据是否出现错误。 通过使用FPGA实现CRC校验，可以高效地处理数据，并能够在传输过程中快速检测出数据是否出现错误。FPGA的灵活性使得校验位长度和生成多项式能够根据需要进行改变，提高了系统的可定制性和应用范围。同时，FPGA的并行计算能力也使得CRC计算速度更快，能够满足高速数据传输的需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值