原理

原理我就不详细介绍了，维基百科什么的有很多，大概意思就是这么一套操作过后可以极大概率地检测出数据错误。我又怎么会告诉你们我也没有完全看懂。

实现

直接计算法

/**
 * CRC32 校验函数
 * @param pdata 数据指针
 * @param len 数据长度
 * @param crc 初值或上段数据校验结果
 * @param poly 多项式
 */
uint32_t CRC32(const uint8_t* pdata, int len, uint32_t crc, uint32_t poly)
{
    for (int i = 0; i < len; i++, pdata++)
    {
        crc ^= ((uint32_t)*pdata << 24);

        for (int bits = 0; bits < 8; bits++)
        {
            if (crc & 0x80000000)
            {
                crc = (crc << 1) ^ poly;
            }
            else
            {
                crc <<= 1;
            }
        }
    }
    return crc;
}

稍微解释一下代码，大概步骤是：

1. 把新的数据 xor 到之前数据的最高 byte
2. 判断最高 bit，如果是 0 就左移，是 1 就左移后 xor poly
3. 处理完最高 8 个 bits 结束

网上有些例程是右移处理，其实本质是一样的，只要生成 CRC 的程序和校验它的程序是一致的就可以。

为了证明我不是随便找了一段没验证过的代码就贴出来，我这里给出一个 CRC Online Calculator，我贴出的代码能够得出和它一致的结果，各位自己调试代码的时候也可以有个参考。

使用的时候有几点注意：

• 选择 CRC-32
• 由于我给出的代码没有进行位翻转操作，所以选择 Custom，然后两个 reflected 的钩去掉
• Final Xor Value 填 0
• 剩下的你应该懂的

虽然这段代码简单明白，但是网上类似的东西也不少，发个贴子没点干货似乎不太好意思。那么我就多给点料。

查表法

了解多一些的朋友会知道，虽然直接计算的方法代码特别简单，但是循环次数太多效率不够高。根据 xor 运算的结合律特性，可以使用查表法提高运行效率。

static uint32_t gsTable[256];

void CRC32_TableInit(uint32_t poly)
{
    for(uint32_t i = 0; i < 256; i++)
    {
        uint32_t crc = i << 24;

        for (int bits = 0; bits < 8; bits++)
        {
            if (crc & 0x80000000)
            {
                crc = (crc << 1) ^ poly;
            }
            else
            {
                crc <<= 1;
            }
        }

        gsTable[i] = crc;
    }
}

uint32_t CRC32_Table(const uint8_t* pdata, int len, uint32_t crc)
{
    uint8_t index;

    for (int i = 0; i < len; i++, pdata++)
    {
        index = *pdata ^ (crc >> 24);
        crc = (crc << 8) ^ gsTable[index];
    }
    return crc;
}

对比上面的代码，其实就是把 8 bits 的循环抽了出来。从直接计算的代码我们看出，这八次循环的计算效果，其实完全取决于新数据 xor 之后 crc 最高 byte 的值。那么我们如果把这一个 byte 所有可能的值对应的计算结果先存起来，就得到了一个 256 数据的表。

使用的时候就拿 xor 之后的最高 byte 去查表，然后把 crc 直接左移 8 个 bits，再进行一次 xor 就妥了。

有些朋友会疑惑，这样一番操作是不是真的能得到同样的结果。我们可以观察一下表的值，发现它的第 0 个值必然是 0，而第 1 个值，必然等于 poly。为什么呢？因为如果最高 byte 是 0 的话，数据除了会左移 8 个 bits 以外，剩下的 bits 都不会改变（xor 0 值也不变）。而最高 byte 如果是 1 的话，那么它会在第 8 次左移之后 xor 一次 poly。可以看出至少在这两种情况的时候，两段代码的计算效果是等价的，而后面的更多种情况就只能自己体会一下了。

查表法是挺不错，但是网上其实也能找得到。所以呢，就再上一份干货，这是我实际踩过的坑。

STM32 CRC32

下面的代码，与 STM32 中自带的 CRC32 模块的计算效果是等效的。

#define CRC_STM32_POLY          0x04c11db7
#define CRC_STM32_INIT_VALUE    0xFFFFFFFF

uint32_t STM32_CRC32(const uint32_t* pdata, int len, uint32_t crc, uint32_t poly)
{
    for (int i = 0; i < len; i++, pdata++)
    {
        crc ^= *pdata;

        for (int bits = 0; bits < 32; bits++)
        {
            if ((crc & 0x80000000) != 0)
            {
                crc = (crc << 1) ^ poly;
            }
            else
            {
                crc <<= 1;
            }
        }
    }
    return crc;
}

那么它和我们上面一般的 CRC 运算有什么不同呢？细心的朋友可能发现了，它的计算是 32 bits 一轮的，而由于其是小端存储，所以其实是从第四个 byte 的最高 bit 开始计算的。和从第一个 byte 开始计算的 CRC 结果是不一样的，而且输入数据 bytes 个数必须补零到 4 的整数倍。

如果你以为它和一开始介绍的算法一样，就会被它坑到 T^T。而它的算法是内置的，没得修改，所以只要你想用，就必须按它的来。

好了，干货上完，感谢阅读。

Jalon 原创，转载署名，商用联系本人。