变长多字节数据的CRC校验的软硬件实现【原理和代码】

已于 2024-04-02 21:21:20 修改
阅读量800 收藏 15
点赞数 16
分类专栏： 数字IC设计 linux 通信协议 文章标签： 网络协议
于 2024-04-02 15:14:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24287711/article/details/137265951
版权

文章目录

  • 一、软件实现
    • 1.1 串行实现CRC的原理/步骤
    • 1.2 不同算法的串行实现【C语言】
    • 1.3 不同算法的查找表实现方法
  • 二、 FPGA硬件实现
    • 2.1 CRC的verilog生成代码网站
    • 2.2 CRC16_8/ccitt_false 校验示例
  • 三、CRC校验码在线计算网站

参考博客
http://t.csdnimg.cn/E429j
http://t.csdnimg.cn/18yxc
https://b23.tv/WBgvNl5

一、软件实现

参考博客
http://t.csdnimg.cn/E429j

Python有个库pycrc ,可以根据配置参数自动生成各种CRC校验的C语言代码,可以去用一下.当然我是在造完轮子之后才发现的。

CRC的 逐位运算法 和 查表法 是两种独立的操作。
查表法是空间换时间，先存一个大表,然后一个字节(byte)一个字节的计算。
逐位运算是时间换空间，就一小段函数，不过是一位(bit)一位的计算。
其实对于嵌入式应用，有的时候数据很少或者实时性要求不高的情况，逐位运算法是很合适的。

1.1 串行实现CRC的原理/步骤

在这里插入图片描述

  1. 根据不同的CRC算法，初始化CRC校验码为全0或全1；
  2. 设置一个变量DATA，存储要校验的数据；
  3. 设置一个变量POLY，存放CRC多项式；
  4. CRC = CRC^DATA(得到被除数)；
  5. 循环以下过程：循环的次数为DATA的bit数；
  6. 如果CRC的最高位为1，则执行CRC=(CRC<<1)^POLY；
    否则，执行CRC=CRC<<1;
  7. 结束循环，得到的CRC校验值就是最终的校验码。

1.2 不同算法的串行实现【C语言】

/******************************************************************************
 * Name:    CRC-4/ITU           x4+x+1
 * Poly:    0x03
 * Init:    0x00
 * Refin:   True
 * Refout:  True
 * Xorout:  0x00
 * Note:
 *****************************************************************************/
uint8_t crc4_itu(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint8_t crc = 0;		// Initial value
    while(length--)
    {
        crc ^= *data++;	 	// crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0x0C;// 0x0C = (reverse 0x03)>>(8-4)
            else
                crc = (crc >> 1);
        }
    }
    return crc;
}

/******************************************************************************
 * Name:    CRC-5/EPC           x5+x3+1
 * Poly:    0x09
 * Init:    0x09
 * Refin:   False
 * Refout:  False
 * Xorout:  0x00
 * Note:
 *****************************************************************************/
uint8_t crc5_epc(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint8_t crc = 0x48;	// Initial value: 0x48 = 0x09<<(8-5)
    while(length--)
    {
        crc ^= *data++;	// crc ^= *data; data++;
        for ( i = 0; i < 8; i++ )
        {
            if ( crc & 0x80 )
                crc = (crc << 1) ^ 0x48;	// 0x48 = 0x09<<(8-5)
            else
                crc <<= 1;
        }
    }
    return crc >> 3;
}

/******************************************************************************
 * Name:    CRC-5/ITU           x5+x4+x2+1
 * Poly:    0x15
 * Init:    0x00
 * Refin:   True
 * Refout:  True
 * Xorout:  0x00
 * Note:
 *****************************************************************************/
uint8_t crc5_itu(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint8_t crc = 0;		// Initial value
    while(length--)
    {
        crc ^= *data++;	 	// crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0x15;// 0x15 = (reverse 0x15)>>(8-5)
            else
                crc = (crc >> 1);
        }
    }
    return crc;
}

/******************************************************************************
 * Name:    CRC-5/USB           x5+x2+1
 * Poly:    0x05
 * Init:    0x1F
 * Refin:   True
 * Refout:  True
 * Xorout:  0x1F
 * Note:
 *****************************************************************************/
uint8_t crc5_usb(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint8_t crc = 0x1F;		// Initial value
    while(length--)
    {
        crc ^= *data++;	 	// crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0x14;// 0x14 = (reverse 0x05)>>(8-5)
            else
                crc = (crc >> 1);
        }
    }
    return crc ^ 0x1F;
}

/******************************************************************************
 * Name:    CRC-6/ITU           x6+x+1
 * Poly:    0x03
 * Init:    0x00
 * Refin:   True
 * Refout:  True
 * Xorout:  0x00
 * Note:
 *****************************************************************************/
uint8_t crc6_itu(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint8_t crc = 0; 	// Initial value
    while(length--)
    {
        crc ^= *data++;	// crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0x30;// 0x30 = (reverse 0x03)>>(8-6)
            else
                crc = (crc >> 1);
        }
    }
    return crc;
}

/******************************************************************************
 * Name:    CRC-7/MMC           x7+x3+1
 * Poly:    0x09
 * Init:    0x00
 * Refin:   False
 * Refout:  False
 * Xorout:  0x00
 * Use:     MultiMediaCard,SD,ect.
 *****************************************************************************/
uint8_t crc7_mmc(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint8_t crc = 0;	// Initial value
    while(length--)
    {
        crc ^= *data++;	// crc ^= *data; data++;
        for ( i = 0; i < 8; i++ )
        {
            if ( crc & 0x80 )
                crc = (crc << 1) ^ 0x12;	// 0x12 = 0x09<<(8-7)
            else
                crc <<= 1;
        }
    }
    return crc >> 1;
}

/******************************************************************************
 * Name:    CRC-8               x8+x2+x+1
 * Poly:    0x07
 * Init:    0x00
 * Refin:   False
 * Refout:  False
 * Xorout:  0x00
 * Note:
 *****************************************************************************/
uint8_t crc8(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint8_t crc = 0;	// Initial value
    while(length--)
    {
        crc ^= *data++;	// crc ^= *data; data++;
        for ( i = 0; i < 8; i++ )
        {
            if ( crc & 0x80 )
                crc = (crc << 1) ^ 0x07;
            else
                crc <<= 1;
        }
    }
    return crc;
}

/******************************************************************************
 * Name:    CRC-8/ITU           x8+x2+x+1
 * Poly:    0x07
 * Init:    0x00
 * Refin:   False
 * Refout:  False
 * Xorout:  0x55
 * Alias:   CRC-8/ATM
 *****************************************************************************/
uint8_t crc8_itu(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint8_t crc = 0;	// Initial value
    while(length--)
    {
        crc ^= *data++;	// crc ^= *data; data++;
        for ( i = 0; i < 8; i++ )
        {
            if ( crc & 0x80 )
                crc = (crc << 1) ^ 0x07;
            else
                crc <<= 1;
        }
    }
    return crc ^ 0x55;
}

/******************************************************************************
 * Name:    CRC-8/ROHC          x8+x2+x+1
 * Poly:    0x07
 * Init:    0xFF
 * Refin:   True
 * Refout:  True
 * Xorout:  0x00
 * Note:
 *****************************************************************************/
uint8_t crc8_rohc(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint8_t crc = 0xFF; 	// Initial value
    while(length--)
    {
        crc ^= *data++;	    // crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0xE0;	// 0xE0 = reverse 0x07
            else
                crc = (crc >> 1);
        }
    }
    return crc;
}

/******************************************************************************
 * Name:    CRC-8/MAXIM         x8+x5+x4+1
 * Poly:    0x31
 * Init:    0x00
 * Refin:   True
 * Refout:  True
 * Xorout:  0x00
 * Alias:   DOW-CRC,CRC-8/IBUTTON
 * Use:     Maxim(Dallas)'s some devices,e.g. DS18B20
 *****************************************************************************/
uint8_t crc8_maxim(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint8_t crc = 0; 	// Initial value
    while(length--)
    {
        crc ^= *data++;	// crc ^= *data; data++;
        for (i = 0; i < 8; i++)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0x8C;	// 0x8C = reverse 0x31
            else
                crc >>= 1;
        }
    }
    return crc;
}

/******************************************************************************
 * Name:    CRC-16/IBM          x16+x15+x2+1
 * Poly:    0x8005
 * Init:    0x0000
 * Refin:   True
 * Refout:  True
 * Xorout:  0x0000
 * Alias:   CRC-16,CRC-16/ARC,CRC-16/LHA
 *****************************************************************************/
uint16_t crc16_ibm(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint16_t crc = 0;	// Initial value
    while(length--)
    {
        crc ^= *data++;	// crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0xA001;	// 0xA001 = reverse 0x8005
            else
                crc = (crc >> 1);
        }
    }
    return crc;
}

/******************************************************************************
 * Name:    CRC-16/MAXIM        x16+x15+x2+1
 * Poly:    0x8005
 * Init:    0x0000
 * Refin:   True
 * Refout:  True
 * Xorout:  0xFFFF
 * Note:
 *****************************************************************************/
uint16_t crc16_maxim(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint16_t crc = 0;	// Initial value
    while(length--)
    {
        crc ^= *data++;	// crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0xA001;	// 0xA001 = reverse 0x8005
            else
                crc = (crc >> 1);
        }
    }
    return ~crc;    // crc^0xffff
}

/******************************************************************************
 * Name:    CRC-16/USB          x16+x15+x2+1
 * Poly:    0x8005
 * Init:    0xFFFF
 * Refin:   True
 * Refout:  True
 * Xorout:  0xFFFF
 * Note:
 *****************************************************************************/
uint16_t crc16_usb(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint16_t crc = 0xffff;	// Initial value
    while(length--)
    {
        crc ^= *data++;	    // crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0xA001;	// 0xA001 = reverse 0x8005
            else
                crc = (crc >> 1);
        }
    }
    return ~crc;    // crc^0xffff
}

/******************************************************************************
 * Name:    CRC-16/MODBUS       x16+x15+x2+1
 * Poly:    0x8005
 * Init:    0xFFFF
 * Refin:   True
 * Refout:  True
 * Xorout:  0x0000
 * Note:
 *****************************************************************************/
uint16_t crc16_modbus(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint16_t crc = 0xffff;	// Initial value
    while(length--)
    {
        crc ^= *data++;	    // crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0xA001;	// 0xA001 = reverse 0x8005
            else
                crc = (crc >> 1);
        }
    }
    return crc;
}

/******************************************************************************
 * Name:    CRC-16/CCITT        x16+x12+x5+1
 * Poly:    0x1021
 * Init:    0x0000
 * Refin:   True
 * Refout:  True
 * Xorout:  0x0000
 * Alias:   CRC-CCITT,CRC-16/CCITT-TRUE,CRC-16/KERMIT
 *****************************************************************************/
uint16_t crc16_ccitt(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint16_t crc = 0;	// Initial value
    while(length--)
    {
        crc ^= *data++;	// crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0x8408;	// 0x8408 = reverse 0x1021
            else
                crc = (crc >> 1);
        }
    }
    return crc;
}

/******************************************************************************
 * Name:    CRC-16/CCITT-FALSE   x16+x12+x5+1
 * Poly:    0x1021
 * Init:    0xFFFF
 * Refin:   False
 * Refout:  False
 * Xorout:  0x0000
 * Note:
 *****************************************************************************/
uint16_t crc16_ccitt_false(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint16_t crc = 0xffff;	//Initial value
    while(length--)
    {
        crc ^= (uint16_t)(*data++) << 8; // crc ^= (uint6_t)(*data)<<8; data++;
        for (i = 0; i < 8; ++i)
        {
            if ( crc & 0x8000 )
                crc = (crc << 1) ^ 0x1021;
            else
                crc <<= 1;
        }
    }
    return crc;
}

/******************************************************************************
 * Name:    CRC-16/X25          x16+x12+x5+1
 * Poly:    0x1021
 * Init:    0xFFFF
 * Refin:   True
 * Refout:  True
 * Xorout:  0XFFFF
 * Note:
 *****************************************************************************/
uint16_t crc16_x25(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint16_t crc = 0xffff;	// Initial value
    while(length--)
    {
        crc ^= *data++;	    // crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0x8408;	// 0x8408 = reverse 0x1021
            else
                crc = (crc >> 1);
        }
    }
    return ~crc;	        // crc^Xorout
}

/******************************************************************************
 * Name:    CRC-16/XMODEM       x16+x12+x5+1
 * Poly:    0x1021
 * Init:    0x0000
 * Refin:   False
 * Refout:  False
 * Xorout:  0x0000
 * Alias:   CRC-16/ZMODEM,CRC-16/ACORN
 *****************************************************************************/
uint16_t crc16_xmodem(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint16_t crc = 0;	    // Initial value
    while(length--)
    {
        crc ^= (uint16_t)(*data++) << 8; // crc ^= (uint16_t)(*data)<<8; data++;
        for (i = 0; i < 8; ++i)
        {
            if ( crc & 0x8000 )
                crc = (crc << 1) ^ 0x1021;
            else
                crc <<= 1;
        }
    }
    return crc;
}

/******************************************************************************
 * Name:    CRC-16/DNP          x16+x13+x12+x11+x10+x8+x6+x5+x2+1
 * Poly:    0x3D65
 * Init:    0x0000
 * Refin:   True
 * Refout:  True
 * Xorout:  0xFFFF
 * Use:     M-Bus,ect.
 *****************************************************************************/
uint16_t crc16_dnp(uint8_t *data, uint_len length)
{
    uint8_t i;
    uint16_t crc = 0;	    // Initial value
    while(length--)
    {
        crc ^= *data++;	    // crc ^= *data; data++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0xA6BC;	// 0xA6BC = reverse 0x3D65
            else
                crc = (crc >> 1);
        }
    }
    return ~crc;	        // crc^Xorout
}

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

/******************************************************************************
 * 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, uint_len length)
{
    uint8_t i;
    uint32_t crc = 0xffffffff;  // Initial value
    while(length--)
    {
        crc ^= (uint32_t)(*data++) << 24;// crc ^=(uint32_t)(*data)<<24; data++;
        for (i = 0; i < 8; ++i)
        {
            if ( crc & 0x80000000 )
                crc = (crc << 1) ^ 0x04C11DB7;
            else
                crc <<= 1;
        }
    }
    return crc;
}

使用方法如下，校验的数据长度不限。

//1. 首先,根据输入数据长度定义合适的uint_len类型,因为是逐位运算,所以不推荐用在实时性较高的的情况下,而且数据也不宜太长.大多数嵌入式开发过程中需要校验的寄存器数据也不会太多.这里使用:
typedef uint16_t uint_len;
//2. 定义一组测试数据:
uint8_t bytes_test[]={0x11,0x22,0x33,0x44};
//输出测试数据的crc16_8/ccitt_false校验码
printf("%x\n",crc16_ccitt_false(bytes_test, sizeof(bytes_test)));

1.3 不同算法的查找表实现方法

待实现；

二、 FPGA硬件实现

有串行实现和并行实现，其中串行时间消耗的时钟周期数比较多，而并行实现可以在一个时钟周期内完成单字节或者特定长度数据的CRC校验码。
如果要计算可变多字节数据的CRC校验码，可以类比软件的实现方式。先初始化CRC校验码每一位为全0或全1（不同算法不一样），计算单字节的CRC校验码，之后使用得到的校验码和下一个字节数据计算CRC校验码，以此往复，循环止到最后一个有效字节数据，得到的CRC校验码即为最终的CRC校验码！

2.1 CRC的verilog生成代码网站

  1. https://www.easics.com/webtools/crctool （有时候打不开）
  2. http://outputlogic.com/?page_id=321
  3. https://bues.ch/cms/hacking/crcgen 【2和3的网站生成的代码核心是一样的~~】

2.2 CRC16_8/ccitt_false 校验示例

使用outputlogic网站生成的crc16_8/ccitt_false代码如下

//-----------------------------------------------------------------------------
// CRC module for data[7:0] ,   crc[15:0]=1+x^5+x^12+x^16;
//-----------------------------------------------------------------------------
module crc16_8_ccitt_false_one(
  input [7:0]   data_in,
  input         crc_en,
  output [15:0] crc_out,
  input         rst,
  input         clk
);

  reg [15:0] lfsr_q,lfsr_c;

  assign crc_out = lfsr_q;

  always @(*) begin
    lfsr_c[0] = lfsr_q[8] ^ lfsr_q[12] ^ data_in[0] ^ data_in[4];
    lfsr_c[1] = lfsr_q[9] ^ lfsr_q[13] ^ data_in[1] ^ data_in[5];
    lfsr_c[2] = lfsr_q[10] ^ lfsr_q[14] ^ data_in[2] ^ data_in[6];
    lfsr_c[3] = lfsr_q[11] ^ lfsr_q[15] ^ data_in[3] ^ data_in[7];
    lfsr_c[4] = lfsr_q[12] ^ data_in[4];
    lfsr_c[5] = lfsr_q[8] ^ lfsr_q[12] ^ lfsr_q[13] ^ data_in[0] ^ data_in[4] ^ data_in[5];
    lfsr_c[6] = lfsr_q[9] ^ lfsr_q[13] ^ lfsr_q[14] ^ data_in[1] ^ data_in[5] ^ data_in[6];
    lfsr_c[7] = lfsr_q[10] ^ lfsr_q[14] ^ lfsr_q[15] ^ data_in[2] ^ data_in[6] ^ data_in[7];
    lfsr_c[8] = lfsr_q[0] ^ lfsr_q[11] ^ lfsr_q[15] ^ data_in[3] ^ data_in[7];
    lfsr_c[9] = lfsr_q[1] ^ lfsr_q[12] ^ data_in[4];
    lfsr_c[10] = lfsr_q[2] ^ lfsr_q[13] ^ data_in[5];
    lfsr_c[11] = lfsr_q[3] ^ lfsr_q[14] ^ data_in[6];
    lfsr_c[12] = lfsr_q[4] ^ lfsr_q[8] ^ lfsr_q[12] ^ lfsr_q[15] ^ data_in[0] ^ data_in[4] ^ data_in[7];
    lfsr_c[13] = lfsr_q[5] ^ lfsr_q[9] ^ lfsr_q[13] ^ data_in[1] ^ data_in[5];
    lfsr_c[14] = lfsr_q[6] ^ lfsr_q[10] ^ lfsr_q[14] ^ data_in[2] ^ data_in[6];
    lfsr_c[15] = lfsr_q[7] ^ lfsr_q[11] ^ lfsr_q[15] ^ data_in[3] ^ data_in[7];

  end // always

  always @(posedge clk, posedge rst) begin
    if(rst) begin
      lfsr_q <= {16{1'b1}};
    end
    else begin
      lfsr_q <= crc_en ? lfsr_c : lfsr_q;
    end
  end // always
endmodule // crc

稍加修改就可以得到多个字节数据的CRC校验模块

//-----------------------------------------------------------------------------
// CRC module for data[7:0] ,   crc[15:0]=1+x^5+x^12+x^16;
//-----------------------------------------------------------------------------
module crc16_8_ccitt_false_one(
  input [7:0]   data_in,
  input [15:0]  crc_in,
  output [15:0] crc_out
);

  reg [15:0] lfsr_c;
  
  always @(*) begin
    lfsr_c[0]   = crc_in[8] ^ crc_in[12] ^ data_in[0] ^ data_in[4];
    lfsr_c[1]   = crc_in[9] ^ crc_in[13] ^ data_in[1] ^ data_in[5];
    lfsr_c[2]   = crc_in[10] ^ crc_in[14] ^ data_in[2] ^ data_in[6];
    lfsr_c[3]   = crc_in[11] ^ crc_in[15] ^ data_in[3] ^ data_in[7];
    lfsr_c[4]   = crc_in[12] ^ data_in[4];
    lfsr_c[5]   = crc_in[8] ^ crc_in[12] ^ crc_in[13] ^ data_in[0] ^ data_in[4] ^ data_in[5];
    lfsr_c[6]   = crc_in[9] ^ crc_in[13] ^ crc_in[14] ^ data_in[1] ^ data_in[5] ^ data_in[6];
    lfsr_c[7]   = crc_in[10] ^ crc_in[14] ^ crc_in[15] ^ data_in[2] ^ data_in[6] ^ data_in[7];
    lfsr_c[8]   = crc_in[0] ^ crc_in[11] ^ crc_in[15] ^ data_in[3] ^ data_in[7];
    lfsr_c[9]   = crc_in[1] ^ crc_in[12] ^ data_in[4];
    lfsr_c[10]  = crc_in[2] ^ crc_in[13] ^ data_in[5];
    lfsr_c[11]  = crc_in[3] ^ crc_in[14] ^ data_in[6];
    lfsr_c[12]  = crc_in[4] ^ crc_in[8] ^ crc_in[12] ^ crc_in[15] ^ data_in[0] ^ data_in[4] ^ data_in[7];
    lfsr_c[13]  = crc_in[5] ^ crc_in[9] ^ crc_in[13] ^ data_in[1] ^ data_in[5];
    lfsr_c[14]  = crc_in[6] ^ crc_in[10] ^ crc_in[14] ^ data_in[2] ^ data_in[6];
    lfsr_c[15]  = crc_in[7] ^ crc_in[11] ^ crc_in[15] ^ data_in[3] ^ data_in[7];
  end // always
  assign crc_out = lfsr_c;

endmodule // crc

下边的crc16_8_ccitt_false_severals模块会调用上边的crc16_8_ccitt_false_one模块，得到多个变长字节数据的CRC校验码。
可以根据自己的需求进行修改！！！

module crc16_8_ccitt_false_severals(
    input        clk            ,
    input        rstn           ,
    input [7:0]  data_in[29:0]  ,
    input [7:0]  data_in_len    ,
    input        crc_en         ,
    output       crc_vaild      ,
    output[15:0] crc16_out

);
    reg  [7:0]  data_index;
    reg  [7:0]  data_one_byte;
    reg  [15:0] crc_in;  
    wire [15:0] crc_out_middle;

    always @(posedge clk or negedge rstn) begin
        if(rstn == 1'b0)
            data_one_byte <= data_in[30-1];
        else if(data_index < data_in_len && crc_en == 1'b1 )
            data_one_byte <= data_in[30-data_index-1];
        else
            data_one_byte <= data_in[30-1];
    end

    always @(posedge clk or negedge rstn) begin
        if(rstn == 1'b0)
            crc_in <= 16'hFFFF;
        else if(data_index < data_in_len && crc_en == 1'b1)
            crc_in <= crc_out_middle;
        else
            crc_in <= 16'hFFFF;
    end

    always @(posedge clk or negedge rstn) begin
        if(rstn == 1'b0)
            data_index <= 8'b1;
        else if(data_index < data_in_len && crc_en == 1'b1)
            data_index <= data_index + 8'b1;
        else
            data_index <= 8'b1;
    end 

    assign crc_vaild = ~(data_index < data_in_len);

    crc16_8_ccitt_false_one u_crc16_8_ccitt_false_one(
        .data_in            ( data_one_byte  ),
        .crc_in             ( crc_in         ),
        .crc_out            ( crc_out_middle )
    );

endmodule

仿真代码：计算四字节数据的crc16_8_ccitt_false校验码：

module tb_crc16_ccitt_sevels();
    reg clk;
    reg rst;
    reg [7:0]   data_in[29:0];
    reg [7:0]   data_in_len;
    reg crc_en;

    crc16_8_ccitt_false_sevels u_crc16_8_ccitt_false_sevels(
        .clk            ( clk           ),
        .rstn           ( rst           ),
        .data_in        ( data_in       ),
        .data_in_len    ( data_in_len   ),
        .crc_en         ( crc_en        ),
        .crc_vaild      (               ),
        .crc16_out      (               )
    );

    initial begin
        clk             = 1'b0;
        rst             = 1'b0;
        crc_en          = 1'b0;
        data_in[26]     = 8'h44;
        data_in[27]     = 8'h33;
        data_in[28]     = 8'h22;
        data_in[29]     = 8'h11;
        data_in_len     = 8'h4;

        #1000 rst       = 1'b1;
        #1000 crc_en    = 1'b1;

        #10000;
        $finish;
    end
    always #10 clk <= ~ clk;

    initial begin
        $fsdbDumpfile("./wave.fsdb");
        $fsdbDumpvars(0);
        $fsdbDumpMDA();
    end
endmodule

仿真结果，当crc_vaild拉高时，说明CRC计算完毕。计算得到的CRC校验码与网站（http://www.ip33.com/crc.html）计算一致。

在这里插入图片描述

三、CRC校验码在线计算网站

http://www.ip33.com/crc.html
软件或者硬件方式得到的CRC校验结果，可以和在线网站计算的结果进行比较，来验证自己模块设计正确与否！

本人不是专门研究数学和算法的，文章如有表述错误或问题，欢迎指出！

飘～～～～
关注
  • 16
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CRC校验
Leav
07-08 899
CRC校验就是在被校验的数后跟上一个校验没
2019上半年网络工程师(软考)真题及解析.pdf
08-10
3. **循环冗余校验（CRC）**：CRC是一种检错技术，通过在数据后面附加一个校验位，使得整个数据串能被预先约定的生成多项式整除。接收端同样用该生成多项式进行校验，如果无法整除，说明传输过程中出现了错误。 4. ...
CRC校验码生成与数据校验源码程序 (包括CRC-4,5,6,7,8,16,32)
04-23
附件包括crc.h,crc.c,main.c 博文链接：https://kiolp.iteye.com/blog/2262455
CRC计算单元
shaun2001的博客
06-13 722
雅特力单片机CRC计算单元介绍
stm32h7硬件crc的使用
u012936480的博客
05-09 229
软件CRC耗时158us，硬件CRC耗时44us，硬件CRC的速度是软件CRC的4倍。STM32H753的硬件CRC功能可以快速计算数据的CRC校验值，提高系统的数据完整性和安全性。它支持不同的CRC算法，如CRC-32、CRC-16和CRC-8等。用户可以根据应用需求选择合适的CRC算法。硬件CRC的计算过程不会占用CPU资源，因为STM32H753拥有专门的硬件模块用于计算CRC校验值。这意味着CPU可以在计算CRC的同时执行其他任务，从而提高系统的处理能力和效率。
CRC16多字节校验程序
09-10
做modbus通讯时需要用到CRC校验程序，网上大多是对短字节的校验软件，自己编写的多字节CRC16校验程序，最高支持256字节
C#: CRC8,CRC16,CRC32 校验代码
yutian0606的博客
01-17 927
说明：CRC即循环冗余校验码（Cyclic Redundancy Check）：是数据通信领域中最常用的一种查错校验码，其特征是信息字段和校验字段的长度可以任意选定。循环冗余检查（CRC）是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性和完整性。
【计算机网络】CRC校验码的代码实现
Mitchell_Donovan的博客
08-11 2474
应用所学知识，编写代码实现CRC计算和验证功能，并验证CRC编码检验的成功率。
CRC校验码的源代码
胸怀世界，一点一滴的编程可以改变世界，实现梦想。
06-18 1273
很多网络协议都用到CRC校验码，当自己编写网络协议的时候，也需要编写相应的CRC代码，来进行校验，网上有很多类似的代码，但是有些很麻烦，也不一定高效，我现在提供一个很高效，也很容易理解的CRC校验方法，希望能够对大家有所帮助。 int calcByte(int crc, char b)//这个函数是用来进行位运算的，主要为下面的计算CRC来服务 {      int i;  crc =
基于RS485总线的数据采集系统下位机软硬件设计.zip_Labview编码_labview rs485_labview 编码_
09-21
5. **安全性和稳定性**：考虑系统的容错能力和安全性，比如在数据传输中使用CRC校验或更高级的错误检测机制，以及在网络异常时的恢复策略。 通过以上步骤，我们可以构建一个可靠且高效的基于RS485总线的数据采集...
计算机组成原理习题集.pdf
10-06
6. 操作系统(A)的功能是对计算机软硬件资源进行管理，提供用户与计算机之间的接口，以及管理操作计算机的资源。 7. 微型计算机的发展以微处理器(B)技术为标志，微处理器的发展推动了计算机的微型化和性能提升。 8....
CRC校验码计算软件_源代码
09-28
1.CRC-16/MODBUS（最通用） 2.CRC-16/CCITT-FALSE 支持以上CRC校验计算方式（分查表法和计算法），原代码可执行，能正确输出结果。需要的朋友可以直接 引用到自己项目中。谢谢支持。
在单片机上实现USB移动存储.doc
10-02
在单片机上实现USB移动存储是一项复杂而关键的技术，涉及到软硬件的综合设计。USB移动存储设备的主要功能是提供可移动的数据存储和传输能力，它通常由USB主机接口和相应的驱动固件组成。 首先，从系统总体设计的...
2019年11月下半年网络工程师真题试卷(空白卷).pdf
08-21
16. CRC校验码计算：根据生成多项式X5+X3+1，传输数据10101110，CRC校验码为10001。 17. CSMA/CD冲突最小时间：两主机相距2km，信号传播速度200m/us，最短冲突时间为40us，即两主机同时检测到冲突的时间。 18. ...
CRC校验码实现
Goodness2020的博客
12-05 323
CRC校验码实现
CRC校验代码整理
wuhuijun165的博客
08-07 3922
CRC
CRC校验码详解+Verilog实现（含代码）
居安士的博客
10-09 5303
CRC码简介 CRC校验码生成步骤 CRC码生成多项式 CRC校验码Verilog实现
CRC校验原理及代码实现
weixin_43487974的博客
07-31 5220
CRC校验及代码具体实现
【udp报文】udp报文未自动分片，报文过长被拦截问题定位
最新发布
剑指Offer编程题
07-02 435
修改mtu值对udp报文进行分片传输
怎么对1024个字节数据进行crc校验
06-09
对于1024个字节的数据进行CRC校验，可以采用以下步骤： 1. 定义一个`uint8_t`类型的数组来存储这1024个字节的数据。 2. 调用CRC16函数，将数据数组和数据长度作为参数传递给函数。 3. 将CRC16校验码的高8位和低8位分别存储到两个字节中，可以使用`uint16_t`类型的变量进行存储。 以下是一个简单的C语言实现示例： ```c #include <stdio.h> #include <stdint.h> uint16_t crc16(uint8_t *data, uint16_t len); int main() { uint8_t data[1024]; // 存储1024个字节的数据 // 在这里填充数据数组... uint16_t crc = crc16(data, 1024); // 调用CRC16函数计算校验码 uint8_t crc_high = (uint8_t)((crc >> 8) & 0xFF); // 获取CRC高8位 uint8_t crc_low = (uint8_t)(crc & 0xFF); // 获取CRC低8位 // 在这里可以将CRC高8位和低8位写入到需要的位置... return 0; } ``` 在上述示例中，我们通过调用`crc16`函数计算出了数据的CRC16校验码，并将其高8位和低8位分别存储到了两个字节中。最终可以根据需求将这两个字节写入到需要的位置。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值