精华内容
下载资源
问答
  • 循环冗余校验在一些传输协议中,发送端并不指出消息长度,而是采用结束标志,考虑以下几种差错:1)在消息之前,增加1个或多个0字节;2)消息以1个或多个连续的0字节开始,丢掉1个或多个0;3)在消息(包括校验码)之后,...

    接收端对收到的len 2字节执行do_crc,如果没有差错发生则结果应为0。循环冗余校验

    在一些传输协议中,发送端并不指出消息长度,而是采用结束标志,考虑以下几种差错:

    1)在消息之前,增加1个或多个0字节;

    2)消息以1个或多个连续的0字节开始,丢掉1个或多个0;

    3)在消息(包括校验码)之后,增加1个或多个0字节;

    4)消息(包括校验码)以1个或多个连续的0字节结尾,丢掉1个或多个0;

    显然,这几种差错都检测不出来,其原因就是如果寄存器为0,处理0消息字节(或位),寄存器不变。为了解决前2个问题,只需寄存器的初非0即可,对do_crc作以下改进:

    unsigned short do_crc(unsigned short reg_init, unsigned char *message, unsigned int len)

    {

    unsigned short crc_reg = reg_init;

    while (len--)

    crc_reg = (crc_reg >> 8) ^ crc16_ccitt_table[(crc_reg ^ *message) & 0xff];

    return crc_reg;

    }

    在CRC16-CCITT标准中reg_init = 0xffff,为了解决后2个问题,在CRC16-CCITT标准中将计算出的校验码与0xffff进行异或,即:

    unsigned short code = do_crc(0xffff, message, len);

    code ^= 0xffff;

    message[len] = code & 0x00ff;

    message[len 1] = (code >> 8) & 0x00ff;

    显然,现在接收端对收到的所有字节执行do_crc,如果没有差错发生则结果应为某一常GOOD_CRC。其满足以下关系:

    unsigned char p[]= {0xff, 0xff};

    GOOD_CRC = do_crc(0, p, 2);

    其结果为GOOD_CRC = 0xf0b8。

    在同一程序中验证如下(放在main函数中可试验):

    unsigned char p[]= {0xa0,0xb0,0xff, 0xff};

    unsigned short crc;

    crc= do_crc(0xffff, p, 2); //计算前两位的CRC码

    crc^=0xffff; //对其取反

    p[2]=crc&0x00ff; //将计算的CRC码加到信息序列后面

    p[3]=crc>>8&0x00ff;

    printf("p[2]=%x,p3=%x\n",p[2],p[3]);

    crc=do_crc(0xffff,p,4); //对信息码+CRC码共同计算得出CRC=0xf0b8

    printf("crc is %x\n",crc);

    假设发送的信息是p[0],p[1];低位先发,对其计算的CRC加到信息码后面

    然后对信息码+CRC码共同计算CRC,此时应该是常数0xf0b8。不管信息码如何变化,内容和长度都可变,只要把计算的CRC码加进去一起计算CRC,就应该是得该常数GOOD_CRC。

    参考文献

    --------

    [1] Ross N. Williams,"A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS",Version 3,

    ,August 1993

    [2] Simpson, W., Editor, "PPP in HDLC Framing",RFC 1549, December 1993

    [3] P. E. Boudreau,W. C. Bergman and D. R. lrvin,"Performance of a cyclic redundancy check and its interaction with a data scrambler",IBM J. RES. DEVELOP.,VOL.38 NO.6,November 1994

    本文来自电脑杂谈,转载请注明本文网址:

    http://www.pc-fly.com/a/tongxinshuyu/article-38614-6.html

    展开全文
  • 若需要进一步了解线性码、分组码、循环码、纠错编码等方面的原理,可以阅读有关资料。利用CRC进行检错的过程可简单描述为:在发送端根据要传送的k位二进制码序列,以一定的规则产生一个校验用的r位监督 码(CRC码),...

    5d1201e9a455f446206af216ecb02ab8.png

    CRC的全称为Cyclic Redundancy Check,中文名称为

    差错控制理论是在代数理论基础上建立起来的。这里我们着于介绍CRC的算法与实现,对原理只能捎带说明一下。若需要进一步了解线性码、分组码、循环码、纠错编码等方面的原理,可以阅读有关资料。

    利用CRC进行检错的过程可简单描述为:在发送端根据要传送的k位二进制码序列,以一定的规则产生一个校验用的r位监督 码(CRC码),附在原始信息后边,构成一个新的二进制码序列数共kr位,然后发送出去。在接收端,根据信息码和CRC码之间所遵循的规则进行检验,以 确定传送中是否出错。这个规则,在差错控制理论中称为“生成多项式”。

    1 代数学的一般性算法

    在代数编码理论中,将一个码组表示为一个多项式,码组中各码元当作多项式的系数。例如 1100101 表示为

    1·x61·x50·x40·x31·x20·x1,即 x6x5x21。

    设编码前的原始信息多项式为P(x),P(x)的最高幂次加1等于k;生成多项式为G(x),G(x)的最高幂次等于r;CRC多项式为R(x);编码后的带CRC的信息多项式为T(x)。

    发送方编码方法:将P(x)乘以xr(即对应的二进制码序列左移r位),再除以G(x),所得余式即为R(x)。用公式表示为

    T(x)=xrP(x)R(x)

    接收方解码方法:将T(x)除以G(x),如果余数为0,则说明传输中无错误发生,否则说明传输有误。

    举例来说,设信息码为1100,生成多项式为1011,即P(x)=x3x2,G(x)=x3x1,计算CRC的过程为

    即 R(x)=x。注意到G(x)最高幂次r=3,得出CRC为010。

    如果用竖式除法,计算过程为

    因此,T(x)=(x6x5)(x)=x6x5x, 即 1100000010=1100010

    如果传输无误,

    无余式。回头看一下上面的竖式除法,如果被除数是1100010,显然在商第三个1时,就能除尽。

    上述推算过程,有助于我们理解CRC的概念。但直接编程来实现上面的算法,不仅繁琐,效率也不高。实际上在工程中不会直接这样去计算和验证CRC。

    下表中列出了一些见于标准的CRC资料:

    ISO HDLC, ITU X.25, V.34/V.41/V.42, PPP-FCS

    ZIP, RAR, IEEE 802 LAN/FDDI, IEEE 1394, PPP-FCS

    4.CRC算法的实现

    ---------------

    要用程序实现CRC算法,考虑对第2节的长除法做一下变换,依然是M = 11100110,G = 1011,

    其系数r为3。

    11001100

    ------------------------

    1011 )11100110000

    1011.......

    ----.......

    1010......

    1011......

    ----......

    1110...

    1011...

    ------...

    1010..

    1011..

    -------

    100

    本文来自电脑杂谈,转载请注明本文网址:

    http://www.pc-fly.com/a/tongxinshuyu/article-38614-1.html

    展开全文
  • 计算循环冗余码Description计算机网络中采用循环冗余码来校验数据的正确性。其原理是:发送方计算出待发送的二进制数据的循环冗余码,并随同原数据一起发送到接收方;接收方通过重新计算接收到的数据的循环冗余码,并...

    计算循环冗余码

    Description

    计算机网络中采用循环冗余码来校验数据的正确性。其原理是:发送方计算出待发送的二进制数据的循环冗余码,并随同原数据一起发送到接收方;接收方通过重新计算接收到的数据的循环冗余码,并和收到的循环冗余码进行比较,如果两者相同则可判定所收到的数据是正确的,否则说明数据是错误的。其中计算二进制数据的循环冗余码的计算过程如下:

    1.协议事先约定一个二进制生成表达式,本题设为10011;

    2.将待发送的二进制数据串的末尾加4个0;

    3.将补上0的数据串按模2除法除于生成表达式,取余数;

    4.该余数就是该二进制数据串的循环冗余码。 例如:

    数据串为:1101011011

    生成表达式为:10011

    循环冗余码为:1110 计算过程如下:

    根据上述的计算方法,请编写一个循环冗余码计算程序,假设二进制数据串的长度不超过20位,生成表达式固定为10011。

    Input

    输入的第一行含一个正整数k (1<=k<=10),表示测试例的个数。后面紧接着k行,每行对应一个测试例,含一个N位二进制串(1<=N<=20),代表数据。

    Output

    每个测试例对应一行输出,含一个5位二进制串,表示循环冗余码。

    Sample Input

    2110101101110101010

    Sample Output

    0111001001

    解题思路:

    模拟。

    AC代码:

    #include

    #include

    #include

    using namespace std;

    char str[30];

    char b[]="10011";

    int main(){

    int T;

    scanf("%d",&T);

    while(T--){

    getchar();

    scanf("%s",str);

    strcat(str,"0000");

    int len = strlen(str);

    for(int i = 0; i < len-4; ++i){

    if(str[i] == '0')

    continue;

    int k = i;

    for(int j = 0; j < 5; ++j,++k){

    if(str[k]^b[j])

    str[k] = '1';

    else

    str[k] = '0';

    }

    }

    for(int i = len-5; i < len; ++i)

    printf("%c",str[i]);

    printf("\n");

    }

    return 0;

    }

    展开全文
  • CRC(循环冗余校验)查表算法的代码实现前言准备工作查表算法的由来查表算法的基本原理模二减法(异或运算)的性质对直接计算法进行分析基本原理的推广查表算法的代码实现测试用例正式编码代码的测试仓库地址 ...

    前言

    CRC基本原理、数学描述和直接计算法的编程实现请参考笔者之前的劣文:
    https://blog.csdn.net/weixin_44256803/article/details/105805628

    本文假设读者已有以上CRC基础

    各种CRC类型汇总:https://reveng.sourceforge.io/crc-catalogue/

    准备工作

    在正式进入查表算法的代码实现之前,需要先明白算法原理。

    查表算法的由来

    通过分析直接计算法的实现,很容易看出直接计算法中对于每一位数据都做了移位运算,遇到置1的位还会进行与多项式的模二减法(异或运算),这会大大降低算法的效率(时间复杂度过大):
    逐位计算
    能不能不要逐位计算,一次算好几位来提高速度呢?

    查表算法的基本原理

    模二减法(异或运算)的性质

    在学习查表算法原理之前需要先了解模二减法(异或运算)的性质:

    交换律:a ^ b = b ^ a
    结合律:a ^ b ^ c = a ^ (b ^ c)

    交换律很容易理解,结合律举例:
    0110B ^ 0101B ^ 1001B = 1010B
    0110B ^ (0101B ^ 1001B) = 0110B ^ 1100B = 1010B

    对直接计算法进行分析

    假设要传输的原始数据为1101011011B,发送方和接收方在通信前约定好的除数为10011B。由于除数10011B是五位数(5bit),那么假设余数(即CRC码)为四位数(4bit)。因为现在余数未知,所以在进行模二除法运算前先将余数设为0000B,即待发送的数据为11010110110000B。下面开始进行模二除法运算来确定余数(即CRC码):
    直接计算法
    我们将原始数据每两位拆开看:11B, 01B, 01B, 10B, 11B.
    一一分解计算步骤并运用模二减法的交换律和结合律(即先算某部分的CRC码,再与原始数据的某部分作模二减法)不难发现:第一个两位(11B)的CRC校验值(0101B)的前两位(01B)会与接下来的第二个两位(01B)做模二减法(异或运算)运算结果(00B)的CRC校验值(0000B不妨记为temp)的前两位(00B)又会与第一个两位(11B)的CRC校验值(0101B)的后两位(01B)做模二减法(异或运算)运算结果(01B)与temp的后两位(00B)即组成了原始数据前四位(1101B)的CRC码(0100B);接下来原始数据前四位(1101B)CRC校验值的前两位又会与第三个两位(01B)做模二减法(异或运算)……以此类推,最终算出的CRC校验值即为原始数据的CRC码。

    由此抽象出数学模型:将计算CRC校验值这一过程记为函数f();将第一个两位(11B)记作sh1;将第二个两位(01B)记作sh2。则得到:

    f(sh1 << 2 + sh2) = (f(sh1) << 2) ^ f((f(sh1) >> 2) ^ sh2)

    至此,已经得到按两位查表算法的基本原理,等式右侧的f()函数调用即为查表操作。

    基本原理的推广

    实际应用中,按两位查表算法有时仍然不够高效。因此,可以推广到按四位查表、按字节查表。但很容易发现,随着查表位数的增加,所查的表会指数级变大:两位表的大小22=4;四位表的大小24=16;八位表的大小28=256等等。这说明随着查表算法的时间复杂度减小,空间复杂度会增加。而具体的查表位数则根据实际的应用场景来选取,例如:对于嵌入式而言,受RAM空间大小限制,可以提前计算好余式表,这样一来就会将其写入静态常量区而节省RAM;若资源紧张,在意表的大小,也可以选择较小的四位表;而对于PC,由于RAM足够,可以选择按字节查表甚至更大;若时间要求高,在意性能,则可以选择数据吞吐量更大的多表查询算法、四切片法、八切片法等,对于这些时间复杂度小、空间复杂度高的算法此处不再扩展。若有兴趣请参考http://create.stephan-brumme.com/crc32/

    查表算法的代码实现

    测试用例

    在算法的代码实现之前,可以先提前写好测试用例。这里以C++为例。选取CRC-16/CCITT-FALSE为测试的CRC类型,该类型的参数如下:

    width=16
    poly=0x1021
    init=0xffff
    refin=false
    refout=false
    xorout=0x0000
    check=0x29b1
    residue=0x0000
    name=“CRC-16/IBM-3740”
    Alias: CRC-16/AUTOSAR, CRC-16/CCITT-FALSE

    因为CRC类型繁多且位数差异较大,有64位甚至大于64位的,也有3位、4位的,所以考虑用模板实现。例如大于16位小于等于32位的,采用unsigned int类型实现,大于32位小于等于64位的,采用unsigned long long类型实现。

    //CrcTest.h
    #pragma once
    
    #include<iostream>
    #include<iomanip>
    
    #define WIDTH 16
    #define POLY 0x1021     
    #define INIT 0xffff     
    #define REFIN false
    #define REFOUT false
    #define XOROUT 0x0000     
    
    #ifdef WIDTH
    #if WIDTH <= 8
    typedef unsigned char crcType;
    #elif WIDTH > 8 && WIDTH <= 16
    typedef unsigned short crcType;
    #elif WIDTH > 16 && WIDTH <= 32
    typedef unsigned int crcType;
    #elif WIDTH > 32 && WIDTH <= 64
    typedef unsigned long long crcType;
    #endif // WIDTH <= 8
    #endif // WIDTH
    
    void testCalculateCrc();
    //CrcTest.h
    
    //CrcTest.cpp
    #include"CrcTest.h"
    #include"CrcCalculator.h"
    
    using namespace std;
    
    int main()
    {
    	unsigned char input[] = { '1', '2', '3', '4', '5', '6', '7', '8', '9' };
    	cout << "0x" << setw((size_t)ceil(WIDTH / 4)) << setfill('0') << hex <<
    		calculateCrc<crcType>(input, sizeof(input), WIDTH, POLY, INIT, REFIN, REFOUT, XOROUT) << endl;
    	cin.get();
    	return 0;
    }
    //CrcTest.cpp
    

    正式编码

    最后,终于到了正式编码的部分了!这里抛砖引玉,以实现按字节查表为例。

    首先,我们根据测试用例,规划好将要编程的文件:CrcCalculator.h,因为要用到模板,所以索性将函数的实现与声明写在一块儿避免麻烦。由于余式表的生成还是需要直接计算得到的,需要先编写直接计算CRC的方法,笔者之前博文有提及所以这里直接贴代码:

    //CrcCalculator.h
    #pragma once
    
    /// <summary>
    /// 将输入的数按位倒序
    /// </summary>
    /// <param name="input">待按位倒序的数</param>
    /// <param name="width">CRC位宽</param>
    /// <returns>按位倒序后的数</returns>
    template<typename T> T reverseBit(T input, size_t width)
    {
        T output = 0;
        for (size_t i = 0; i < width; i++)//根据CRC位宽确定循环次数
        {
            output <<= 1;//将output左移使上一次循环中确定的位变为高位,同时在本次循环中确定LSB
            if (input & 1)//根据当前input的LSB确定当前output的LSB
            {
                output |= 1;
            }
            input >>= 1;//将input右移以便在下一次循环中获取下一个高位
        }
        return output;
    }
    /// <summary>
    /// 直接计算CRC校验值
    /// </summary>
    /// <param name="pData">待计算数据的头指针</param>
    /// <param name="length">待计算数据长度</param>
    /// <param name="width">CRC位宽</param>
    /// <param name="poly">CRC多项式</param>
    /// <param name="init">输入初始值</param>
    /// <param name="refin">输入是否反转</param>
    /// <param name="refout">输出是否反转</param>
    /// <param name="xorout">输出异或值</param>
    /// <returns>CRC校验值</returns>
    template<typename T> T calculateCrcDirectly(
        unsigned char* pData,
        size_t length,
        size_t width,
        T poly,
        T init,
        bool refin,
        bool refout,
        T xorout)
    {
        //计算掩码
        T mask = 0;
        for (size_t i = 0; i < width; i++)
        {
            mask = (mask << 1) | 1;
        }
    
        T ret = init;
        while (length-- > 0)//根据输入数据的字节数依次计算
        {
            if (refin)
            {
                ret ^= reverseBit<T>(*pData++, width);
            }
            else
            {
                ret ^= static_cast<T>(*pData++) << (width - 8);
            }
            for (size_t i = 0; i < 8; i++)//按输入字节的每一位进行计算
            {
                if (ret & (static_cast<T>(1) << (width - 1)))//若首位是1则进行左移并与多项式进行模二减法(异或运算)
                {
                    ret = ((ret << 1) & mask) ^ poly;
                }
                else//否则继续左移
                {
                    ret = ((ret << 1) & mask);
                }
            }
        }
        if (refout)
        {
            return reverseBit<T>(ret ^ xorout, width);
        }
        else
        {
            return ret ^ xorout;
        }
    }
    //CrcCalculator.h
    

    接下来就是如何实现查边算法。首先,需要利用直接计算法生成一张余式表:

    //CrcCalculator.h
    /// <summary>
    /// 计算CRC余式表
    /// </summary>
    /// <param name="table">CRC余式表头指针</param>
    /// <param name="width">CRC位宽</param>
    /// <param name="poly">CRC多项式</param>
    /// <param name="refin">输入是否反转</param>
    /// <param name="refout">输出是否反转</param>
    template<typename T> void calculateCrcTable(
        T* table,
        size_t width,
        T poly,
        bool refin,
        bool refout)
    {
        for (size_t i = 0; i < 256; i++)
        {
            unsigned char data = static_cast<unsigned char>(i);
            table[i] = calculateCrcDirectly<T>(&data, sizeof(data), width, poly, 0, refin, refout, 0);
        }
    }
    //CrcCalculator.h
    

    注意,为了避免之后的循环所可能产生的反复按位反转(当refin、refout为真时),我们在生成余式表的时候就带上这层信息,后续的循环中就可以靠左移、右移来区分是否反转。

    基于上面探索基本原理时所抽象的数学模型我们可以总结得到基本循环体伪代码(按字节查找):

    本次CRC = (上次CRC左移一个字节) ^ 查表获得CRC(上次CRC的最高字节 ^ 本次读取的字节数据)

    进一步地用代码表达:

    thisCrc = (lastCrc << 8) ^ crcTable[(lastCrc >> (crcWidth - 8)) ^ thisByte];

    而对于按位反转的CRC类型而言,我们已经在生成余式表时进行过反转,因此CRC已经是高低位互换,在循环中只需逆向位移即可:

    thisCrc = (lastCrc >> 8) ^ crcTable[(lastCrc ^ thisByte) & 0xff];

    注意:由于CRC位宽可能不止8位,因此需要与掩码0xff作按位与以剔除其余字节。

    下面贴出实现细节:

    //CrcCalculator.h
    /// <summary>
    /// 计算CRC校验值
    /// </summary>
    /// <param name="pData">待计算数据的头指针</param>
    /// <param name="length">待计算数据长度</param>
    /// <param name="width">CRC位宽</param>
    /// <param name="poly">CRC多项式</param>
    /// <param name="init">输入初始值</param>
    /// <param name="refin">输入是否反转</param>
    /// <param name="refout">输出是否反转</param>
    /// <param name="xorout">输出异或值</param>
    /// <returns>CRC校验值</returns>
    template<typename T> T calculateCrc(
        unsigned char* pData,
        size_t length,
        size_t width,
        T poly,
        T init,
        bool refin,
        bool refout,
        T xorout)
    {
        //计算掩码
        T mask = 0;
        for (size_t i = 0; i < width; i++)
        {
            mask = (mask << 1) | 1;
        }
    
        T table[256];
        calculateCrcTable<T>(table, width, poly, refin, refout);
    
        T ret = init;
        while (length-- > 0)
        {
            if (refin)
            {
                ret = (ret >> 8) ^ table[(ret ^ *pData++) & 0xff];
            }
            else
            {
                ret = ((ret << 8) & mask) ^ table[(ret >> (width - 8)) ^ *pData++];
            }
        }
        return ret ^ xorout;
    }
    //CrcCalculator.h
    

    代码的测试

    在VS中进行调试:
    测试结果
    与该模型的check值一致。

    此外,对于嵌入式开发,可以先提前计算好余式表节省RAM。因此,添加一个打印余式表的测试用例:

    //CrcTest.h
    void testCalculateCrcTable()
    {
    	crcType table[256];
    	calculateCrcTable<crcType>(table, WIDTH,  POLY, REFIN, REFOUT);
    	cout << "{" << endl;
    	for (size_t i = 0; i < 256; i++)
    	{
    		cout << "0x" << setw((size_t)ceil(WIDTH / 4)) << setfill('0') << hex << table[i];
    		if (i < 255)
    		{
    			cout << ", ";
    		}
    		if (i % 8 == 7)
    		{
    			cout << endl;
    		}
    	}
    	cout << "}";
    }
    //CrcTest.h
    

    打印余式表

    仓库地址

    https://github.com/blingbling-110/CrcLib
    读者可以自行测试其他更低位/更高位CRC类型并打印出余式表以使用。

    展开全文
  • 循环冗余 今天学习计算机网络的时候对于循环冗余校验不是很理解,所以在此总结并加深一下理解 使用循环冗余的目的 主要是用来检测或校验数据传输或者保存后可能出现的错误 原理 在发送端将数据划分为组,假定...
  • 验证网址: ...CRC-16/CCITT-FALSE验证 需要校验的数据:abc 数据的十六进制:61 62 63 参数模型:CRC-16/CCITT-FALSE ...将校验结果添加到校验的数据后面:61 62 63 51 4A,重新计算校验结果为0000. 校验完成 CRC-16/XMOD
  • 常用的校验方式有奇偶校验、异或校验、累加和校验(可以看我之前的一篇文章累加和校验算法(CheckSum算法))、循环冗余校验(CRC校验)等等。 奇偶校验、异或校验、累加和校验都比较简单,且易于实现,但是检错能力...
  • /*===================================================== 功能:CRC16冗余循环校验 参数:unsigned char *puchMsg ; //要进行CRC校验的消息 unsigned short usDataLen ; //消息中字节数 ========================...
  • 【计算机网络】CRC校验码||循环冗余码详解及计算习题
  • package test;public class test1 {public static int[] crc(int[] data) {int[] temdata = new int[data.length + 2];// unsigned char alen = ... //CRC16只计算前两部分int xda, xdapoly;int i, j, xdabit;xda = ...
  • 关于循环冗余码的定义,可以百度:http://baike.baidu.com/view/575295.htm#sub575295计算余数的二进制除法第一步,要在数据位(被除数)后边补 0 , 0 的个数比除数(生成多项式)少一位。第二步,做除法,从被除数的头五...
  • 电脑系统提示数据错误循环冗余检查怎么办?有时候复制文件或是进行其他操作时,系统提示数据错误循环冗余检查,这该如何解决呢?下面给大家介绍具体解决方法。解决方法:1、如果是从硬盘的某一个盘符复制到另一个...
  • 循环冗余校验(Cyclic Redundancy Check, CRC)是一种根据网络数据包或计算机文件等数据产生简短固定位数校验码的一种信道编码技术,主要用来检测或校验数据传输或者保存后可能出现的错误。它是利用除法及余数的原理...
  • 2018年真题11题,这个题特别坑,估计当时考的时候,没几个人会算吧!...关于校验码、CRC循环冗余校验的理论知识这里不赘述了,参考链接 http://www.ylaihui.com/blog/article/9273?rootCategoryId=16 ..
  • 描述一、CRC简介循环冗余校验(Cyclic Redundancy Check, CRC)是一种根据网络数据包或电脑文件等数据产生简短固定位数校验码的一种散列函数,主要用来检测或校验数据传输或者保存后可能出现的错误。它是利用除法及...
  • 如何简单的计算且通俗的理解CRC码(循环冗余校验码)CRC码的出现的契机什么是模2运算怎么简单的求CRC码 CRC码的出现的契机 CRC(Cyclic Redundancy Check)码即循环冗余校验码 ,在计算机运行及数据传输时,由于种种...
  • CRC校验(循环冗余校验)是数据通讯中最常采用的校验方式。在嵌入式软件开发中,经常要用到CRC 算法对各种数据进行校验。因此,掌握基本的CRC算法应是嵌入式程序员的基本技能。 从奇偶校验说起 所谓通讯过程的校验是...
  • CRC校验原理 CRC校验原理看起来比较复杂,好难懂,因为大多数书上基本上是以二进制的... 通过以上CRC校验原理的剖析和CRC校验码的计算示例的介绍,大家应该对这种看似很复杂的CRC校验原理和计算方法应该比较清楚了。
  • 我们通过一个简单的例子来说明循环冗余检验的原理。 在发送端,先把数据划分为组,假设每组k个比特。现假定待传输的数据 M=101001(k=6)。CRC 运算就是在数据 M 的后面添加供差错检测用的 n 位冗余码,然后构成一个...
  • 一般用得比较多的校验码有奇偶校验码,CRC循环冗余校验码,海明校验码等。这里只介绍用的最多的CRC循环冗余校验码。何为校验码校验码是通过一种计算方法,发出端在原始数据的尾部添加若干数据;然后接...
  • 冗余码:用M’除以P,得出余数R,R为n位 将得出的R添加在M’中最后n个0的位置 即可得出最终应传送的数据 注:此过程中的计算,均不产生进位,采用相同得0,相异得1的规则 例题详解 要发送的数据序列为101011,设...
  • 循环冗余校验码(CRC)详解

    千次阅读 2021-04-09 11:46:20
    循环冗余校验码(CRC)广泛应用于数据通信领域和磁介质存储系统中。它利用生成多项式为k个数据未产生r个校验位来进行编码,其编码长度为k+r。由此可知,循环冗余校验码是由两部分组成的,左边为信息码(数据),右边...
  • 循环冗余校验码的思想: 例题: 注:产生的余数为R位(比除数少一位)二进制数。 注:这里与海明码不同,余数转换成十进制后的数与出错位没有必然的联系。 ——————————————————————————...
  • 现在此说明下什么是CRC:循环冗余码校验 英文名称为Cyclical Redundancy Check,简称CRC,它是利用除法及余数的原理来作错误侦测(Error Detecting)的。实际应用时,发送装置计算出CRC值并随数据一同发送给接收装置,...
  • 在数据链路层中,最广泛应用的检错码是一种漏检率很低也便于硬件实现的循环冗余校验码CRC(Cyclic Redundancy Code)。 1、CRC码 CRC码又称多项式码,任何一个由二进制位数串组成的代码都可由一个只含有0和1两个系数...
  • 循环冗余校验码CRC

    2021-05-27 15:44:17
    循环冗余校验码(Cyclic Redundancy Chec,CRC)广泛应用于移动通信和磁盘数据存储中。CRC 也是给信息码加上几位校验码,以增加整个编码系统的码距和查错纠错能力。 原理 CRC 的基本原理是:在 K 位信息码后再添加 R...
  • 比起奇偶校验码(PCC)只能校验一位错误,循环冗余校验码(CRC)的检错能力更强,可以检出多位错误。 1.CRC校验原理 CRC校验原理看起来比较复杂,好难懂,因为大多数书上基本上是以二进制的多项式形式来说明的。其实...
  • 循环冗余码(CRC)又称为多项式编码,将任何一个由二进制位串组成的编码,与一个只含有0和1两个系数的多项式建立一一对应关系。如:位串1010111对应的多项式为;多项式对应的位串为101111。 多项式的算术运算采用代...
  • CRC循环冗余校验码 我们知道不同的校验码都有着独特的校验方法,CRC校验码则是根据余数来进行校验的。 简单的来讲就是现在我要给你发送数据,我们来保证这串数据除以5没有余数,那么你拿到数据后想要判断它有没有...
  • @Component public class Crc16Util { /*************************************... 描 述: CRC16 循环冗余校验算法。 参 数 一: *puchMsg:需要校验的字符串指针 参 数 二: usDataLen:要校验的字符串长度 返 回 ..

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,105
精华内容 24,442
关键字:

循环冗余计算