CRC16常见的标准

最新推荐文章于 2024-01-18 17:22:10 发布
最新推荐文章于 2024-01-18 17:22:10 发布
阅读量504 收藏 10
点赞数 9
分类专栏： C语言 文章标签： c语言 CRC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zdwcmy/article/details/135491308
版权

本文整理CRC16常见的标准算法，有以下几种：

模式多项式初始值数据位序结果处理
CRC16_CCITTx16+x12+x5+1（0x1021）0x0000低位在前，高位在后与0x0000异或
CRC16_CCITT_FALSEx16+x12+x5+1（0x1021）0xFFFF低位在后，高位在前与0x0000异或
CRC16_XMODEMx16+x12+x5+1（0x1021）0x0000低位在后，高位在前与0x0000异或
CRC16_X25x16+x12+x5+1（0x1021）0xFFFF低位在前，高位在后与0xFFFF异或
CRC16_ MODBUSx16+x15+x2+1（0x8005）0xFFFF低位在前，高位在后与0x0000异或
CRC16_ IBMx16+x15+x2+1（0x8005）0x0000低位在前，高位在后与0x0000异或
CRC16_ MAXIMx16+x15+x2+1（0x8005）0x0000低位在前，高位在后与0xFFFF异或
CRC16_ USBx16+x15+x2+1（0x8005）0xFFFF低位在前，高位在后与0xFFFF异或

多项式产生：
如x16+x12+x5+1
x16表示第16位为1，x5表示第5位为1
(1 << 16) | (1 << 12) | (1 << 5) | (1) = 0x11021
但是CRC16只取低16位，写成16进制数就是 0x1021

CRC16的算法原理：

1.根据CRC16的标准选择初值CRCIn的值。

2.将数据的第一个字节与CRCIn高8位异或。

3.判断最高位，若该位为 0 左移一位，若为 1 左移一位再与多项式Hex码异或。

4.重复3直至8位全部移位计算结束。

5.重复将所有输入数据操作完成以上步骤，所得16位数即16位CRC校验码。

根据算法原理与标准要求就能简单的写出具体程序：CRC算法参数模型解释： 
    NAME：参数模型名称。 
    WIDTH：宽度，即CRC比特数。 
    POLY：生成项的简写，以16进制表示。例如：CRC-32即是0x04C11DB7，忽略了最高位的"1"，即完整的生成项是0x104C11DB7。 
    INIT：这是算法开始时寄存器（crc）的初始化预置值，十六进制表示。 
    REFIN：待测数据的每个字节是否按位反转，True或False。 
    REFOUT：在计算后之后，异或输出之前，整个数据是否按位反转，True或False。 
    XOROUT：计算结果与此参数异或后得到最终的CRC值。
    Alias：别名及其应用范围。

/****************************Info********************************************** 
 * Name:    CRC-16/CCITT        x16+x12+x5+1 
 * Width:    16
 * Poly:    0x1021 
 * Init:    0x0000 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0x0000 
 * Alias:   CRC-CCITT,CRC-16/CCITT-TRUE,CRC-16/KERMIT 
 *****************************************************************************/ 
#if 0
unsigned short CRC16_CCITT(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0x0000;
    unsigned short wCPoly = 0x1021;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar << 8);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x8000)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint16(&wCRCin,&wCRCin);
    return (wCRCin);
}
#else 
//这里为了效率，我们不需要将所有Refin和refout为true的输入输出数据移位转换
//只需要将poly二项式转换后，运算时将左移变为右移
unsigned short CRC16_CCITT(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0x0000;
    unsigned short wCPoly = 0x1021;
    unsigned char wChar = 0;
    
    InvertUint16(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ wCPoly;
            else
                wCRCin = wCRCin >> 1;
        }
    }
    return (wCRCin);
}
#endif
/****************************Info********************************************** 
 * Name:    CRC-16/CCITT-FALSE   x16+x12+x5+1 
 * Width:    16 
 * Poly:    0x1021 
 * Init:    0xFFFF 
 * Refin:   False 
 * Refout:  False 
 * Xorout:  0x0000 
 * Note: 
 *****************************************************************************/ 
unsigned short CRC16_CCITT_FALSE(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0xFFFF;
    unsigned short wCPoly = 0x1021;
    
    while (datalen--)     
    {
        wCRCin ^= *(data++) << 8;
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x8000)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    return (wCRCin);
}
/****************************Info********************************************** 
 * Name:    CRC-16/XMODEM       x16+x12+x5+1 
 * Width:    16 
 * Poly:    0x1021 
 * Init:    0x0000 
 * Refin:   False 
 * Refout:  False 
 * Xorout:  0x0000 
 * Alias:   CRC-16/ZMODEM,CRC-16/ACORN 
 *****************************************************************************/ 
unsigned short CRC16_XMODEM(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0x0000;
    unsigned short wCPoly = 0x1021;
    
    while (datalen--)     
    {
        wCRCin ^= (*(data++) << 8);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x8000)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    return (wCRCin);
}
/****************************Info********************************************** 
 * Name:    CRC-16/X25          x16+x12+x5+1 
 * Width:    16 
 * Poly:    0x1021 
 * Init:    0xFFFF 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0XFFFF 
 * Note: 
 *****************************************************************************/
#if 0 
unsigned short CRC16_X25(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0xFFFF;
    unsigned short wCPoly = 0x1021;
    unsigned char wChar = 0;
 
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar << 8);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x8000)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint16(&wCRCin,&wCRCin);
    return (wCRCin^0xFFFF);
}
#else 
unsigned short CRC16_X25(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0xFFFF;
    unsigned short wCPoly = 0x1021;
    
    InvertUint16(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ wCPoly;
            else
                wCRCin = wCRCin >> 1;
        }
    }
    return (wCRCin^0xFFFF);
}
#endif
/****************************Info********************************************** 
 * Name:    CRC-16/MODBUS       x16+x15+x2+1 
 * Width:    16 
 * Poly:    0x8005 
 * Init:    0xFFFF 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0x0000 
 * Note: 
 *****************************************************************************/
#if 0 
unsigned short CRC16_MODBUS(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0xFFFF;
    unsigned short wCPoly = 0x8005;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar << 8);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x8000)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint16(&wCRCin,&wCRCin);
    return (wCRCin);
}
#else 
unsigned short CRC16_MODBUS(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0xFFFF;
    unsigned short wCPoly = 0x8005;
    
    InvertUint16(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ wCPoly;
            else
                wCRCin = wCRCin >> 1;
        }
    }
    return (wCRCin);
}
#endif
/****************************Info********************************************** 
 * Name:    CRC-16/IBM          x16+x15+x2+1 
 * Width:    16 
 * Poly:    0x8005 
 * Init:    0x0000 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0x0000 
 * Alias:   CRC-16,CRC-16/ARC,CRC-16/LHA 
 *****************************************************************************/ 
#if 0
unsigned short CRC16_IBM(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0x0000;
    unsigned short wCPoly = 0x8005;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar << 8);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x8000)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint16(&wCRCin,&wCRCin);
    return (wCRCin);
}
#else 
unsigned short CRC16_IBM(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0x0000;
    unsigned short wCPoly = 0x8005;
    
    InvertUint16(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ wCPoly;
            else
                wCRCin = wCRCin >> 1;
        }
    }
    return (wCRCin);
}
#endif
/****************************Info********************************************** 
 * Name:    CRC-16/MAXIM        x16+x15+x2+1 
 * Width:    16 
 * Poly:    0x8005 
 * Init:    0x0000 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0xFFFF 
 * Note: 
 *****************************************************************************/
#if 0
unsigned short CRC16_MAXIM(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0x0000;
    unsigned short wCPoly = 0x8005;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar << 8);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x8000)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint16(&wCRCin,&wCRCin);
    return (wCRCin^0xFFFF);
}
#else 
unsigned short CRC16_MAXIM(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0x0000;
    unsigned short wCPoly = 0x8005;
    
    InvertUint16(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ wCPoly;
            else
                wCRCin = wCRCin >> 1;
        }
    }
    return (wCRCin^0xFFFF);
}
#endif
/****************************Info********************************************** 
 * Name:    CRC-16/USB          x16+x15+x2+1 
 * Width:    16 
 * Poly:    0x8005 
 * Init:    0xFFFF 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0xFFFF 
 * Note: 
 *****************************************************************************/ 
#if 0
unsigned short CRC16_USB(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0xFFFF;
    unsigned short wCPoly = 0x8005;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar << 8);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x8000)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint16(&wCRCin,&wCRCin);
    return (wCRCin^0xFFFF);
}
#else 
unsigned short CRC16_USB(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0xFFFF;
    unsigned short wCPoly = 0x8005;
    
    InvertUint16(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ wCPoly;
            else
                wCRCin = wCRCin >> 1;
        }
    }
    return (wCRCin^0xFFFF);
}
#endif
/****************************Info********************************************** 
 * Name:    CRC-16/DNP          x16+x13+x12+x11+x10+x8+x6+x5+x2+1 
 * Width:    16 
 * Poly:    0x3D65 
 * Init:    0x0000 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0xFFFF 
 * Use:     M-Bus,ect. 
 *****************************************************************************/  
#if 0
unsigned short CRC16_DNP(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0x0000;
    unsigned short wCPoly = 0x3D65;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar << 8);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x8000)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint16(&wCRCin,&wCRCin);
    return (wCRCin^0xFFFF) ;
}
#else
unsigned short CRC16_DNP(unsigned char *data, unsigned int datalen)
{
    unsigned short wCRCin = 0x0000;
    unsigned short wCPoly = 0x3D65;
    
    InvertUint16(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ wCPoly;
            else
                wCRCin = (wCRCin >> 1);
        }
    }
    return (wCRCin^0xFFFF);
}
#endif


/****************************Info********************************************** 
 * Name:    InvertUint8 
 * Note:     把字节颠倒过来，如0x12变成0x48
            0x12: 0001 0010
            0x48: 0100 1000
 *****************************************************************************/
void InvertUint8(unsigned char *dBuf,unsigned char *srcBuf)
{
    int i;
    unsigned char tmp[4]={0};
 
    for(i=0;i< 8;i++)
    {
        if(srcBuf[0]& (1 << i))
        tmp[0]|=1<<(7-i);
    }
    dBuf[0] = tmp[0];
    
}

void InvertUint16(unsigned short *dBuf,unsigned short *srcBuf)
{
    int i;
    unsigned short tmp[4]={0};
 
    for(i=0;i< 16;i++)
    {
        if(srcBuf[0]& (1 << i))
        tmp[0]|=1<<(15 - i);
    }
    dBuf[0] = tmp[0];
}

void InvertUint32(unsigned int *dBuf,unsigned int *srcBuf)
{
    int i;
    unsigned int tmp[4]={0};
    
    for(i=0;i< 32;i++)
    {
        if(srcBuf[0]& (1 << i))
        tmp[0]|=1<<(31 - i);
    }
    dBuf[0] = tmp[0];
}

在这个基础上也加入CRC32 的校验算法

/****************************Info********************************************** 
 * Name:    CRC-32  x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1 
 * Width:    32 
 * Poly:    0x4C11DB7 
 * Init:    0xFFFFFFF 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0xFFFFFFF 
 * Alias:   CRC_32/ADCCP 
 * Use:     WinRAR,ect. 
 *****************************************************************************/  
#if 0
unsigned int CRC32(unsigned char *data, unsigned int datalen)
{
    unsigned int wCRCin = 0xFFFFFFFF;
    unsigned int wCPoly = 0x04C11DB7;
    unsigned int wChar = 0;
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8((unsigned char *)&wChar,(unsigned char *)&wChar);
        wCRCin ^= (wChar << 24);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80000000)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint32(&wCRCin,&wCRCin);
    return (wCRCin ^ 0xFFFFFFFF) ;
}
#else
unsigned int CRC32(unsigned char *data, unsigned int datalen)
{
 
    unsigned int wCRCin = 0xFFFFFFFF;
    unsigned int wCPoly = 0x04C11DB7;
 
    InvertUint32(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ wCPoly;
            else
                wCRCin = wCRCin >> 1;
        }
    }
    return (wCRCin ^ 0xFFFFFFFF) ;
}
#endif
/****************************Info********************************************** 
 * Name:    CRC-32/MPEG-2  x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1 
 * Width:    32 
 * Poly:    0x4C11DB7 
 * Init:    0xFFFFFFF 
 * Refin:   False 
 * Refout:  False 
 * Xorout:  0x0000000 
 * Note: 
 *****************************************************************************/ 
unsigned int CRC32_MPEG(unsigned char *data, unsigned int datalen)
{
 
    unsigned int wCRCin = 0xFFFFFFFF;
    unsigned int wCPoly = 0x04C11DB7;
    unsigned int wChar = 0;
    while (datalen--)     
    {
        wChar = *(data++);
        wCRCin ^= (wChar << 24);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80000000)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    return (wCRCin) ;
}
对于CRC32可能还有其他的多项式和初始值和结果值是否需要异或以及输入数据是否需要位序倒转等要求在源码中修改

本次在CRC算法的基础上加入CRC-4,5,6,7,8的各个算法实现：

/****************************Info********************************************** 
 * Name:    CRC-4/ITU    x4+x+1 
 * Width:    4
 * Poly:    0x03 
 * Init:    0x00 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0x00 
 * Note: 
 *****************************************************************************/
unsigned char CRC4_ITU(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0x00;
    unsigned char wCPoly = 0x03;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80)
                wCRCin = (wCRCin << 1) ^ (wCPoly << 4);
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint8(&wCRCin,&wCRCin);
    return (wCRCin);
}
/****************************Info********************************************** 
 * Name:    CRC-5/EPC    x5+x3+1 
 * Width:    5
 * Poly:    0x09 
 * Init:    0x09 
 * Refin:   False 
 * Refout:  False 
 * Xorout:  0x00 
 * Note: 
 *****************************************************************************/
unsigned char CRC5_EPC(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0x09<<3;
    unsigned char wCPoly = 0x09<<3;
    
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80)
                wCRCin = (wCRCin << 1) ^ (wCPoly);
            else
                wCRCin = wCRCin << 1;
        }
    }
    return (wCRCin >> 3);
}
/****************************Info********************************************** 
 * Name:    CRC-5/USB    x5+x2+1 
 * Width:    5
 * Poly:    0x05 
 * Init:    0x1F 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0x1F 
 * Note: 
 *****************************************************************************/
#if 0
unsigned char CRC5_USB(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0x1F<<3;
    unsigned char wCPoly = 0x05;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80)
                wCRCin = (wCRCin << 1) ^ (wCPoly << 3);
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint8(&wCRCin,&wCRCin);
    return (wCRCin^0x1F);
}
#else
unsigned char CRC5_USB(unsigned char *data, unsigned int datalen)  
{  
    unsigned char wCRCin = 0x1F;
    unsigned char wCPoly = 0x05;
    
    InvertUint8(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ (wCPoly >> 3);
            else
                wCRCin = wCRCin >> 1;
        }
    }
    return (wCRCin^0x1F); 
} 
#endif
/****************************Info********************************************** 
 * Name:    CRC-5/ITU    x5+x4+x2+1  
 * Width:    5
 * Poly:    0x15 
 * Init:    0x00 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0x00 
 * Note: 
 *****************************************************************************/
 #if 0
unsigned char CRC5_ITU(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0x00;
    unsigned char wCPoly = 0x15;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80)
                wCRCin = (wCRCin << 1) ^ (wCPoly << 3);
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint8(&wCRCin,&wCRCin);
    return (wCRCin);
}
#else
unsigned char CRC5_ITU(unsigned char *data, unsigned int datalen)  
{  
    unsigned char wCRCin = 0x00;
    unsigned char wCPoly = 0x15;
    
    InvertUint8(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ (wCPoly >> 3);
            else
                wCRCin = wCRCin >> 1;
        }
    }
    return (wCRCin); 
} 
#endif
/****************************Info********************************************** 
 * Name:    CRC-6/ITU    x6+x+1 
 * Width:    6
 * Poly:    0x03 
 * Init:    0x00 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0x00 
 * Note: 
 *****************************************************************************/
unsigned char CRC6_ITU(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0x00;
    unsigned char wCPoly = 0x03;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80)
                wCRCin = (wCRCin << 1) ^ (wCPoly << 2);
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint8(&wCRCin,&wCRCin);
    return (wCRCin);
}
/****************************Info********************************************** 
 * Name:    CRC-7/MMC           x7+x3+1  
 * Width:    7
 * Poly:    0x09 
 * Init:    0x00 
 * Refin:   False 
 * Refout:  False 
 * Xorout:  0x00 
 * Use:     MultiMediaCard,SD,ect. 
 *****************************************************************************/
unsigned char CRC7_MMC(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0x00;
    unsigned char wCPoly = 0x09;
    
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80)
                wCRCin = (wCRCin << 1) ^ (wCPoly<<1);
            else
                wCRCin = wCRCin << 1;
        }
    }
    return (wCRCin>>1);
}
/****************************Info********************************************** 
 * Name:    CRC-8               x8+x2+x+1 
 * Width:    8 
 * Poly:    0x07 
 * Init:    0x00 
 * Refin:   False 
 * Refout:  False 
 * Xorout:  0x00 
 * Note: 
 *****************************************************************************/
unsigned char CRC8(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0x00;
    unsigned char wCPoly = 0x07;
    
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    return (wCRCin);
}
/****************************Info********************************************** 
 * Name:    CRC-8/ITU           x8+x2+x+1 
 * Width:    8 
 * Poly:    0x07 
 * Init:    0x00 
 * Refin:   False 
 * Refout:  False 
 * Xorout:  0x55 
 * Alias:   CRC-8/ATM 
 *****************************************************************************/
unsigned char CRC8_ITU(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0x00;
    unsigned char wCPoly = 0x07;
    
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    return (wCRCin^0x55);
}
/****************************Info********************************************** 
 * Name:    CRC-8/ROHC          x8+x2+x+1 
 * Width:    8 
 * Poly:    0x07 
 * Init:    0xFF 
 * Refin:   True 
 * Refout:  True 
 * Xorout:  0x00 
 * Note: 
 *****************************************************************************/
#if 0
unsigned char CRC8_ROHC(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0xFF;
    unsigned char wCPoly = 0x07;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar << 0);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint8(&wCRCin,&wCRCin);
    return (wCRCin);
}
#else 
unsigned char CRC8_ROHC(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0xFF;
    unsigned char wCPoly = 0x07;
    
    InvertUint8(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ wCPoly;
            else
                wCRCin = wCRCin >> 1;
        }
    }
    return (wCRCin);
}
#endif
/****************************Info********************************************** 
 * Name:    CRC-8/MAXIM         x8+x5+x4+1 
 * Width:    8 
 * 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 
 *****************************************************************************/ 
#if 0
unsigned char CRC8_MAXIM(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0x00;
    unsigned char wCPoly = 0x31;
    unsigned char wChar = 0;
    
    while (datalen--)     
    {
        wChar = *(data++);
        InvertUint8(&wChar,&wChar);
        wCRCin ^= (wChar << 0);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x80)
                wCRCin = (wCRCin << 1) ^ wCPoly;
            else
                wCRCin = wCRCin << 1;
        }
    }
    InvertUint8(&wCRCin,&wCRCin);
    return (wCRCin);
}
#else 
unsigned char CRC8_MAXIM(unsigned char *data, unsigned int datalen)
{
    unsigned char wCRCin = 0x00;
    unsigned char wCPoly = 0x31;
    
    InvertUint8(&wCPoly,&wCPoly);
    while (datalen--)     
    {
        wCRCin ^= *(data++);
        for(int i = 0;i < 8;i++)
        {
            if(wCRCin & 0x01)
                wCRCin = (wCRCin >> 1) ^ wCPoly;
            else
                wCRCin = wCRCin >> 1;
        }
    }
    return (wCRCin);
}
#endif
dw.z
关注
  • 9
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现CRC16校校验
05-23
C语言实现标准CRC16校验 ,文件包含crc.h 和crc.c，有问题可以 私聊我 q-175-543-7233
CRC8/CRC16/CRC32常见几个标准的算法及C语言实现
03-15
用表驱动法来实现CRC8、CRC16、CRC32的数据校验，程序简洁，通俗易懂
JAVACRC16标准校验CCITT
09-17
标准的CCITT校验，CRC16位码，很准确，网上找的好多都不靠谱，这个是经过多伦测试出的结果，和C通信校验完全一致
CRC16 校验算法
06-25
网络上有许多关于CRC16循环冗余校验码的算法介绍，尽管其介绍的内容是客观的，但在涉及到具体的算法实现时，代码往往却是错误的。 针对上述问题，此处提供一段实现代码供大家参考，该代码基于CCITT标准采用查表的方式计算给定字串的CRC16值。 代码已在linux下测试通过，可以放心使用。
crc16ModBus通信
09-26
本代码中是crc16Modbus校验码，直接粘贴进方法就行，高低位可分。
每天记录学习的新知识：CRC16
嗯...
05-05 5068
当接收到数据时，接收器可以使用相同的算法计算自己的校验和，并将其与接收到的数据一起进行比较。如果两个校验和匹配，数据被认为是无误的。CRC16（16位循环冗余校验）是一种用于检测数字数据中错误的编码方式。它通过对一个数据块（通常是消息或信息包）生成一个校验和，然后将其附加到数据的末尾来实现。该算法将数据视为一系列位，并对该序列执行位分割运算，使用多项式进行除法运算。这个除法的余数就是CRC16校验和，它被附加到原始数据的末尾。最常见的变体是CRC-16-CCITT和CRC-16-ANSI。
CRC16按位计算简单代码
fenglifeng1987的专栏
07-21 6911
1．设置CRC寄存器，并给其赋值FFFF(hex)。 2．将数据的第一个8-bit字符与16位CRC寄存器的低8位进行异或，并把结果存入CRC寄存器。 3．CRC寄存器向右移一位，MSB补零，移出并检查LSB。 4．如果LSB为0，重复第三步；若LSB为1，CRC寄存器与多项式码相异或。 注意：该步检查LSB应该是右移前的LSB，即第3步前的LSB。 5．重复第3与第
CRC16
pegasusliuyong的专栏
08-02 3061
CRC选择 当数据帧长度在8bits-128bits范围内时，推荐CRC-8(CRC-8能够减少额外比特的开销，且有更好的性能表现) 当数据帧长度在128bits-2048bits范围内时，推荐CRC-12，CRC-16，CRC-CCITT(CRC-12额外比特的开销更小，且用于6bit字符流的传输；对于16bits的标准，更推荐美国标准CRC-16，性能略优于CRC-CCITT)； 当因数据帧长度更长、信道不稳定等情况而需要更高的性能时，CRC-32、CRC-32C将是更好的选择； CRC简介 CR
菜鸟通俗易懂Linux——CRC16原理与计算方法
desireknowledge_的博客
08-20 2550
​ **循环冗余校验(Cyclic Redundancy Check，CRC)**广泛应用于数据传输中的数据校验，可以自定义校验的位数，例如CRC8、CRC16、CRC32，不同位数也不同的应用场景。第三步 检测寄存器的第一位为0还是1，如果是1，则将寄存器向右移动一位并与多项式的二进制倒叙（比如CRC16_MODBUS 为0x8005 倒叙后为0xA001）进行异或，如果是0，则直接将寄存器向右移动一位。第五步 处理剩下的数据，重复第二、三和四步得到最终的CRC寄存器也就是CRC校验值。
CRC16实现，全网最通俗易懂
不断debug，优化中……
09-17 2286
在这个例子中，我们使用了初始值为0x0000，多项式为0xA001的CRC16-IBM算法。如果你需要实现其他类型的CRC16校验，你需要根据其特性（
CRC16计算方法
weixin_46024507的博客
11-23 2185
CRC16计算方法，ｃ代码实现
CRC16算法及C语言实现
最新发布
那里有颗树
01-18 1027
3.判断最高位，若该位为 0 左移一位，若为 1 左移一位再与多项式Hex码异或。5.重复将所有输入数据操作完成以上步骤，所得16位数即16位CRC校验码。但是CRC16只取低16位，写成16进制数就是 0x1021。1.根据CRC16的标准选择初值CRCIn的值。2.将数据的第一个字节与CRCIn高8位异或。x16表示第16位为1，x5表示第5位为1。4.重复3直至8位全部移位计算结束。如x16+x12+x5+1。
CRC16算法是什么
qq_35872777的博客
04-07 1569
Redis集群CRC16算法
CRC-16校验
m0_53683803的博客
10-18 3614
CRC-16（Cyclic Redundancy Check）校验是一种广泛用于数据传输和存储的差错检测技术。它特别适用于小数据块的完整性验证。在本文中，我们将详细介绍CRC-16校验的原理，并提供使用C语言实现的示例代码。
[单片机] crc16算法
jianqiang.xue
04-15 2296
CRC即循环冗余校验码(Cyclic Redundancy Check)：是数据通信领域中最常用的一种查错校验码，其特征是信息字段和校验字段的长度可以任意选定。奇偶校验虽然简单，但是漏检率太高，而CRC则要低的多，所以大多数都是使用CRC来校验。CRC也称为多项式码。循环冗余检查(CRC)是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附在帧的后面，接收设备也执行类似的算法，进而可以保证在软件层次上数据传输的正确性和完整性。
CRC-16
weixin_45403142的博客
04-14 3723
文章目录A.1 CRC16 算法A.1.1 CRC16 算法参数设置A.1.2 LengthA.1.3 CounterA.1.4 Data IDA.1.5 CRCA.1.6 CRC16 算法示例A.1.7 CRC16 算法推荐(查表法)A.1.8 CRC16 实例(查表法) A.1 CRC16 算法 A.1.1 CRC16 算法参数设置 CRC16 算法中要求了 Counter、Data ID、CRC 等参数设置。 参数 描述 Length 共 16bits，支持长度可变的动态数据，在 CA
得到CRC16校验码的常见几个标准的算法及C语言实现
魏波
07-18 6980
CRC16常见的标准有以下几种，被用在各个规范中，其算法原理基本一致，就是在数据的输入和输出有所差异，下边把这些标准的差异列出，并给出C语言的算法实现。 CRC16_CCITT：多项式x16+x12+x5+1（0x1021），初始值0x0000，低位在前，高位在后，结果与0x0000异或 CRC16_CCITT_FALSE：多项式x16+x12+x5+1（0x1021），初始值0xFFFF，低......
CRC-16校验码原理、实例、手动计算
shjajihoajijso的博客
08-30 1931
假设发送信息用信息多项式C(X)表示，将C(x)左移r位，则可表示成C(x)*2r，这样C(x)的右边就会空出r位校验码的位置，做除法（模2除）假设发送信息用信息多项式C(X)表示，将C(x)左移r位，则可表示成C(x)*2r，这样C(x)的右边就会空出r位校验码的位置，做除法（模2除）发送方通过指定的G(x)产生r位的CRC校验码，接收方则通过该G(x)来验证收到的报文码的CRC校验码是否为0。在k位信息码后再拼接r位的校验码，报文编码长度为n位，因此，这种编码又叫（n，k）码。
CRC16算法
Codeoooo 博客
06-17 1534
1 装一个 16 位寄存器,所有数位均为 1。 2 取被校验串的一个字节与 16 位寄存器的高位字节进行“异或”运算。运算结果放 入这个 16 位寄存器。 3 把这个 16 寄存器向右移一位。 4若向右(标记位)移出的数位是1,则生成多项式1010 0000 0000 0001和这个寄 存器进行“异或”运算;若向右移出的数位是 0,则返回3。 5 重复3和4,直至移出 8 位。 6 取被校验串的下一个字节 7 重复3~6,直至被校验串的所有字节均与 16 位寄存器进行“异或”运算,并移位8次。 8 这个
crc16 ccitt的标准是什么
04-14
CRC16 CCITT（循环冗余校验码）是一种错误检测码，广泛用于通信和存储系统中，以检测数据传输过程中的错误。 标准的CRC16 CCITT是基于ITU-T V.41.，其生成多项式为x^16 + x^12 + x^5 + 1（0x1021）。该算法使用了预设值0xFFFF，按位反转，最终计算出16位的校验值。 在实际应用中，CRC16 CCITT通常以二进制或十六进制形式表示，并与待传输的数据一起发送。接收方会再次计算CRC值，并将其与接收到的CRC值进行比较，以确定数据在传输过程中是否存在错误。如果两个值不匹配，则可以确定存在错误。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值