crc编译码知识
❶ CRC的编码方法
CRC：Cyclic Rendancy Check 循环冗余校验 CRC 校验由于实现简单，检错能力强，被广泛使用在各种数据校验应用中。占用系统资源 少，用软硬件均能实现，是进行数据传输差错检测地一种很好的手段。 CRC 校验码的编码方法是用待发送的二进制数据t（x）除以生成多项式g（x），将最后的余数 作为CRC 校验码。其实现步骤如下： （1） 设待发送的数据块是m 位的二进制多项式t（x），生成多项式为r 阶的g（x）。在数据块 的末尾添加r 个0，数据块的长度增加到m+r 位，对应的二进制多项式为xr t(x) 。 （2） 用生成多项式g（x）去除xr t(x) ，求得余数为阶数为r-1 的二进制多项式y（x）。此二进 制多项式y（x）就是t（x）经过生成多项式g（x）编码的CRC 校验码。 （3） 用xr t(x) 以模2 的方式减去y（x），得到二进制多项式xr t'(x) 。xr t'(x) 就是包含了CRC 校验码的待发送字符串。 从CRC 的编码规则可以看出，CRC 编码实际上是将代发送的m 位二进制多项式t（x）转换成 了可以被g（x）除尽的m+r 位二进制多项式xr t'(x) ，所以解码时可以用接受到的数据去除g（x）， 如果余数位零，则表示传输过程没有错误；如果余数不为零，则在传输过程中肯定存在错误。许多 CRC 的硬件解码电路就是按这种方式进行检错的。同时xr t'(x) 可以看做是由t（x）和CRC 校验码 的组合，所以解码时将接收到的二进制数据去掉尾部的r 位数据，得到的就是原始数据。 为了更清楚的了解CRC 校验码的编码过程，下面用一个简单的例子来说明CRC 校验码的编码 过程。由于CRC-32、CRC-16、CCITT 和CRC-4 的编码过程基本一致，只有位数和生成多项式不 一样。为了叙述简单，用一个CRC-4 编码的例子来说明CRC 的编码过程。 设待发送的数据t（x）为12 位的二进制数据100100011100；CRC-4 的生成多项式为g（x） = x4 + x +1，阶数r 为4，即10011。首先在t（x）的末尾添加4 个0 构成x4t(x) ，数据块就成了 1001000111000000。然后用g（x）去除x4t(x) ，不用管商是多少，只需要求得余数y（x），将y（x）加到数据块末尾的后四位，就生成了编码后的数据块
❷ CRC码的问题
CRC是什么东西呢？其实我们大家都不应该会对它陌生，回忆一下？你用过RAR和ZIP等压缩软件吗？它们是不是常常会给你一个恼人的“CRC校验错误”信息呢？我想你应该明白了吧，CRC就是块数据的计算值，它的全称是“Cyclic Rendancy Check”，中文名是“循环冗余码”，“CRC校验”就是“循环冗余校验”。CRC校验采用多项式编码方法。被处理的数据块可以看作是一个n阶的二进制多项式，由 。如一个8位二进制数10110101可以表示为： 。多项式乘除法运算过程与普通代数多项式的乘除法相同。多项式的加减法运算以2为模，加减时不进，错位，和逻辑异或运算一致。
采用CRC校验时，发送方和接收方用同一个生成多项式g（x）,并且g（x）的首位和最后一位的系数必须为1。CRC的处理方法是：发送方以g（x）去除t（x），得到余数作为CRC校验码。校验时，以计算的校正结果是否为0为据，判断数据帧是否出错。
CRC校验可以100％地检测出所有奇数个随机错误和长度小于等于k（k为g（x）的阶数）的突发错误。所以CRC的生成多项式的阶数越高，那么误判的概率就越小。CCITT建议：2048 kbit/s的PCM基群设备采用CRC-4方案，使用的CRC校验码生成多项式g（x）= 。采用16位CRC校验，可以保证在 bit码元中只含有一位未被检测出的错误 。在IBM的同步数据链路控制规程SDLC的帧校验序列FCS中，使用CRC-16，其生成多项式g（x）= ；而在CCITT推荐的高级数据链路控制规程HDLC的帧校验序列FCS中，使用CCITT-16，其生成多项式g（x）= 。CRC-32的生成多项式g（x）= 。CRC-32出错的概率比CRC-16低 倍 。由于CRC-32的可靠性，把CRC-32用于重要数据传输十分合适，所以在通信、计算机等领域运用十分广泛。在一些UART通信控制芯片（如MC6582、Intel8273和Z80-SIO）内，都采用了CRC校验码进行差错控制；以太网卡芯片、MPEG解码芯片中，也采用CRC-32进行差错控制。
❸ CRC编码步骤
CRC码一般在k位信息位之后拼接r位校验位生成。编码步骤如下：
选择产生多项式为1011，把4位有效信息1100编程CRC码.即G（X）= X^3+X+1=1011，M(x)=X^3+X^2=1100 。
（1）将待编码的k位信息表示成多项式 M(x)。 得到M（X）=1100，即M(x)=X^3+X^2=1100
（2）将 M(x)左移 r 位，得到 M(x)*xr 。则取r=3
M(X)*X^3=X^6+X^5=1100000
（3）用r+1位的生成多项式G(x)去除M(x)*xr 得到余数R(x)。
则被除数为1100000，除数为1011，进行二进制除法，求得余数为010。
（4）将M(x)*xr 与R(x)作模2加，得到CRC码。则CRC校验码为1100010
❹ CRC码的编码和解码程序是什么
我有一个别人变得CRC程序，其中有好几种CRC的编码方法，也许会有用
using System;
namespace Communication.IO.Tools
{
/// <summary>
/// Tool to calculate and add CRC codes to a string
///
/// ***************************************************************************
/// Copyright (c) 2003 Thoraxcentrum, Erasmus MC, The Netherlands.
///
/// Written by Marcel de Wijs with help from a lot of others,
/// especially Stefan Nelwan
///
/// This code is for free. I ported it from several different sources to C#.
///
/// For comments: [email protected]
/// ***************************************************************************
/// </summary>
public class CRCTool
{
// 'order' [1..32] is the CRC polynom order, counted without the leading '1' bit
// 'polynom' is the CRC polynom without leading '1' bit
// 'direct' [0,1] specifies the kind of algorithm: 1=direct, no augmented zero bits
// 'crcinit' is the initial CRC value belonging to that algorithm
// 'crcxor' is the final XOR value
// 'refin' [0,1] specifies if a data byte is reflected before processing (UART) or not
// 'refout' [0,1] specifies if the CRC will be reflected before XOR
// Data character string
// For CRC-CCITT : order = 16, direct=1, poly=0x1021, CRCinit = 0xFFFF, crcxor=0; refin =0, refout=0
// For CRC16: order = 16, direct=1, poly=0x8005, CRCinit = 0x0, crcxor=0x0; refin =1, refout=1
// For CRC32: order = 32, direct=1, poly=0x4c11db7, CRCinit = 0xFFFFFFFF, crcxor=0xFFFFFFFF; refin =1, refout=1
// Default : CRC-CCITT
private int order = 16;
private ulong polynom = 0x1021;
private int direct = 1;
private ulong crcinit = 0xFFFF;
private ulong crcxor = 0x0;
private int refin = 0;
private int refout = 0;
private ulong crcmask;
private ulong crchighbit;
private ulong crcinit_direct;
private ulong crcinit_nondirect;
private ulong [] crctab = new ulong[256];
// Enumeration used in the init function to specify which CRC algorithm to use
public enum CRCCode{CRC_CCITT, CRC16, CRC32};
public CRCTool()
{
//
// TODO: Add constructor logic here
//
}
public void Init(CRCCode CodingType)
{
switch( CodingType )
{
case CRCCode.CRC_CCITT:
order = 16; direct=1; polynom=0x1021; crcinit = 0xFFFF; crcxor=0; refin =0; refout=0;
break;
case CRCCode.CRC16:
order = 16; direct=1; polynom=0x8005; crcinit = 0x0; crcxor=0x0; refin =1; refout=1;
break;
case CRCCode.CRC32:
order = 32; direct=1; polynom=0x4c11db7; crcinit = 0xFFFFFFFF; crcxor=0xFFFFFFFF; refin =1; refout=1;
break;
}
// Initialize all variables for seeding and builing based upon the given coding type
// at first, compute constant bit masks for whole CRC and CRC high bit
crcmask = ((((ulong)1<<(order-1))-1)<<1)|1;
crchighbit = (ulong)1<<(order-1);
// generate lookup table
generate_crc_table();
ulong bit, crc;
int i;
if ( direct == 0 )
{
crcinit_nondirect = crcinit;
crc = crcinit;
for (i=0; i<order; i++)
{
bit = crc & crchighbit;
crc<<= 1;
if ( bit != 0 )
{
crc^= polynom;
}
}
crc&= crcmask;
crcinit_direct = crc;
}
else
{
crcinit_direct = crcinit;
crc = crcinit;
for (i=0; i<order; i++)
{
bit = crc & 1;
if (bit != 0)
{
crc^= polynom;
}
crc >>= 1;
if (bit != 0)
{
crc|= crchighbit;
}
}
crcinit_nondirect = crc;
}
}
/// <summary>
/// 4 ways to calculate the crc checksum. If you have to do a lot of encoding
/// you should use the table functions. Since they use precalculated values, which
/// saves some calculating.
/// </summary>.
public ulong crctablefast (byte[] p)
{
// fast lookup table algorithm without augmented zero bytes, e.g. used in pkzip.
// only usable with polynom orders of 8, 16, 24 or 32.
ulong crc = crcinit_direct;
if ( refin != 0 )
{
crc = reflect(crc, order);
}
if ( refin == 0 )
{
for ( int i = 0; i < p.Length; i++ )
{
crc = (crc << 8) ^ crctab[ ((crc >> (order-8)) & 0xff) ^ p[i]];
}
}
else
{
for ( int i = 0; i < p.Length; i++ )
{
crc = (crc >> 8) ^ crctab[ (crc & 0xff) ^ p[i]];
}
}
if ( (refout^refin) != 0 )
{
crc = reflect(crc, order);
}
crc^= crcxor;
crc&= crcmask;
return(crc);
}
public ulong crctable (byte[] p)
{
// normal lookup table algorithm with augmented zero bytes.
// only usable with polynom orders of 8, 16, 24 or 32.
ulong crc = crcinit_nondirect;
if ( refin != 0 )
{
crc = reflect(crc, order);
}
if ( refin == 0 )
{
for ( int i = 0; i < p.Length; i++ )
{
crc = ((crc << 8) | p[i]) ^ crctab[ (crc >> (order-8)) & 0xff ];
}
}
else
{
for ( int i = 0; i < p.Length; i++ )
{
crc = (ulong)(( (int)(crc >> 8) | (p[i] << (order-8))) ^ (int)crctab[ crc & 0xff ]);
}
}
if ( refin == 0 )
{
for ( int i = 0; i < order/8; i++ )
{
crc = (crc << 8) ^ crctab[ (crc >> (order-8)) & 0xff];
}
}
else
{
for ( int i = 0; i < order/8; i++ )
{
crc = (crc >> 8) ^ crctab[crc & 0xff];
}
}
if ( (refout^refin) != 0 )
{
crc = reflect(crc, order);
}
crc^= crcxor;
crc&= crcmask;
return(crc);
}
public ulong crcbitbybit(byte[] p)
{
// bit by bit algorithm with augmented zero bytes.
// does not use lookup table, suited for polynom orders between 1...32.
int i;
ulong j, c, bit;
ulong crc = crcinit_nondirect;
for (i=0; i<p.Length; i++)
{
c = (ulong)p[i];
if ( refin != 0 )
{
c = reflect(c, 8);
}
for (j=0x80; j != 0; j>>=1)
{
bit = crc & crchighbit;
crc<<= 1;
if ( (c & j) != 0)
{
crc|= 1;
}
if ( bit != 0 )
{
crc^= polynom;
}
}
}
for ( i=0; (int)i < order; i++)
{
bit = crc & crchighbit;
crc<<= 1;
if ( bit != 0 ) crc^= polynom;
}
if ( refout != 0 )
{
crc=reflect(crc, order);
}
crc^= crcxor;
crc&= crcmask;
return(crc);
}
public ulong crcbitbybitfast(byte[] p)
{
// fast bit by bit algorithm without augmented zero bytes.
// does not use lookup table, suited for polynom orders between 1...32.
int i;
ulong j, c, bit;
ulong crc = crcinit_direct;
for (i = 0; i < p.Length; i++)
{
c = (ulong)p[i];
if ( refin != 0)
{
c = reflect(c, 8);
}
for ( j = 0x80; j > 0; j >>= 1 )
{
bit = crc & crchighbit;
crc <<= 1;
if ( (c & j) > 0 ) bit^= crchighbit;
if ( bit > 0 ) crc^= polynom;
}
}
if ( refout > 0)
{
crc=reflect( crc, order );
}
crc^= crcxor;
crc&= crcmask;
return(crc);
}
/// <summary>
/// CalcCRCITT is an algorithm found on the web for calculating the CRCITT checksum
/// It is included to demonstrate that although it looks different it is the same
/// routine as the crcbitbybit* functions. But it is optimized and preconfigured for CRCITT.
/// </summary>
public ushort CalcCRCITT(byte[] p)
{
uint uiCRCITTSum = 0xFFFF;
uint uiByteValue;
for (int iBufferIndex = 0; iBufferIndex < p.Length; iBufferIndex++)
{
uiByteValue = ( (uint) p[iBufferIndex] << 8);
for ( int iBitIndex = 0; iBitIndex < 8; iBitIndex++ )
{
if ( ( (uiCRCITTSum^uiByteValue) & 0x8000) != 0 )
{
uiCRCITTSum = (uiCRCITTSum <<1 ) ^ 0x1021;
}
else
{
uiCRCITTSum <<= 1;
}
uiByteValue <<=1;
}
}
return (ushort)uiCRCITTSum;
}
#region subroutines
private ulong reflect (ulong crc, int bitnum)
{
// reflects the lower 'bitnum' bits of 'crc'
ulong i, j=1, crcout = 0;
for ( i = (ulong)1 <<(bitnum-1); i != 0; i>>=1)
{
if ( ( crc & i ) != 0 )
{
crcout |= j;
}
j<<= 1;
}
return (crcout);
}
private void generate_crc_table()
{
// make CRC lookup table used by table algorithms
int i, j;
ulong bit, crc;
for (i=0; i<256; i++)
{
crc=(ulong)i;
if (refin != 0) // 'refin' [0,1] specifies if a data byte is reflected before processing (UART) or not
{
crc=reflect(crc, 8);
}
crc<<= order-8;
for (j=0; j<8; j++)
{
bit = crc & crchighbit;
crc<<= 1;
if ( bit !=0 ) crc^= polynom;
}
if (refin != 0)
{
crc = reflect(crc, order);
}
crc&= crcmask;
crctab[i]= crc;
}
}
#endregion
}
}
❺ CD-ROM中使用CRC编码的目的及CRC编码的原理
1. 数制与编码进位计数制及其相互转换 真值和机器数 BCD码字符与字符串 校验码 (汉明码,CRC校验等)
2.定点数的表示和运算定点数的表示(无符号数的表示,有符号数的表示)
❻ CRC码是什么
循环冗余校验码（CRC）
CRC校验采用多项式编码方法。被处理的数据块可以看作是一个n阶的二进制多项式，由
。如一个8位二进制数10110101可以表示为：
。多项式乘除法运算过程与普通代数多项式的乘除法相同。多项式的加减法运算以2为模，加减时不进，错位，和逻辑异或运算一致。
采用CRC校验时，发送方和接收方用同一个生成多项式g（x）,并且g（x）的首位和最后一位的系数必须为1。CRC的处理方法是：发送方以g（x）去除t（x），得到余数作为CRC校验码。校验时，以计算的校正结果是否为0为据，判断数据帧是否出错。
CRC校验可以100％地检测出所有奇数个随机错误和长度小于等于k（k为g（x）的阶数）的突发错误。所以CRC的生成多项式的阶数越高，那么误判的概率就越小。CCITT建议：2048
kbit/s的PCM基群设备采用CRC-4方案，使用的CRC校验码生成多项式g（x）=
。采用16位CRC校验，可以保证在
bit码元中只含有一位未被检测出的错误
。在IBM的同步数据链路控制规程SDLC的帧校验序列FCS中，使用CRC-16，其生成多项式g（x）=
；而在CCITT推荐的高级数据链路控制规程HDLC的帧校验序列FCS中，使用CCITT-16，其生成多项式g（x）=
。CRC-32的生成多项式g（x）=
。CRC-32出错的概率比CRC-16低
倍
。由于CRC-32的可靠性，把CRC-32用于重要数据传输十分合适，所以在通信、计算机等领域运用十分广泛。在一些UART通信控制芯片（如MC6582、Intel8273和Z80-SIO）内，都采用了CRC校验码进行差错控制；以太网卡芯片、MPEG解码芯片中，也采用CRC-32进行差错控制。
❼ 什么是CRC码
CRC是什么东西呢？其实我们大家都不应该会对它陌生，回忆一下？你用过RAR和ZIP等压缩软件吗？它们是不是常常会给你一个恼人的“CRC校验错误”信息呢？我想你应该明白了吧，CRC就是块数据的计算值，它的全称是“Cyclic Rendancy Check”，中文名是“循环冗余码”，“CRC校验”就是“循环冗余校验
❽ 什么是CRC校验，原理是什么
CRC即循环冗余校验码（Cyclic Rendancy Check）：是数据通信领域中最常用的一种差错校验码，其特征是信息字段和校验字段的长度可以任意选定。 基本原理是：在K位信息码后再拼接R位的校验码，整个编码长度为N位，因此，这种编码又叫（N，K）码。对于一个给定的（N，K）码，可以证明存在一个最高次幂为N-K=R的多项式G(x)。根据G(x)可以生成K位信息的校验码，而G(x)叫做这个CRC码的生成多项式。 校验码的具体生成过程为：假设发送信息用信息多项式C(X)表示，将C(x)左移R位，则可表示成C(x)*2的R次方，这样C(x)的右边就会空出R位，这就是校验码的位置。通过C(x)*2的R次方除以生成多项式G(x)得到的余数就是校验码。
❾ crc校验码计算方法是什么
已知信息位为1100，生成多项式G(x) = x3+x+1，求CRC码。
M(x) = 1100 M(x)*x3 = 1100000 G(x) = 1011
M(x)*x3 / G(x) = 1110 + 010 /1011 R(x) = 010
CRC码为： M(x)*x 3+R(x)=1100000+010 =1100010
其原理是：CRC码一般在k位信息位之后拼接r位校验位生成。编码步骤如下：
（1）将待编码的k位信息表示成多项式 M(x)。
（2）将 M(x)左移 r 位，得到 M(x)*xr 。
（3）用r+1位的生成多项式G(x)去除M(x)*xr 得到余数R(x)。
（4）将M(x)*xr 与R(x)作模2加，得到CRC码。
(9)crc编译码知识扩展阅读：
CRC校验码计算详解：采用CRC进行差错检验，生成多项式为G(X)=X4+X+1，信息码字为10110，则计算出的CRC校验码是：A. 0000 B. 0100 C. 0010 D.1111
符号表示假定：多项式和多项式的系数排列均用相同的符号表示，如
G(X)= X4+X+1
G(X)=10011
已知条件如下：
原码字记做M(X)，即：M(X) = 10110
生成多项式记做G(X)，即：G(X) = 10011
G(X)的最高阶数记做r，此处r = 4
❿ crc是什么意思
CRC是循环冗余校验（CyclicRendancyCheck）是一种根据网络数据包或计算机文件等数据产生简短固定位数校验码的一种信道编码技术，主要用来检测或校验数据传输或者保存后可能出现的错误。它是利用除法及余数的原理来作错误侦测的。
简介
在数据传输过程中，无论传输系统的设计再怎么完美，差错总会存在，这种差错可能会导致在链路上传输的一个或者多个帧被破坏(出现比特差错，0变为1，或者1变为0)，从而接受方接收到错误的数据。为尽量提高接受方收到数据的正确率，在接收方接收数据之前需要对数据进行差错检测，当且仅当检测的结果为正确时接收方才真正收下数据。检测的方式有多种，常见的有奇偶校验、因特网校验和循环冗余校验等。循环冗余校验是一种用于校验通信链路上数字传输准确性的计算方法（通过某种数学运算来建立数据位和校验位的约定关系的）。发送方计算机使用某公式计算出被传送数据所含信息的一个值，并将此值附在被传送数据后，接收方计算机则对同一数据进行相同的计算，应该得到相同的结果。如果这两个CRC结果不一致，则说明发送中出现了差错，接收方计算机可要求发送方计算机重新发送该数据。
工作原理
循环冗余校验同其他差错检测方式一样，通过在要传输的k比特数据D后添加(n-k)比特冗余位(又称帧检验序列，FrameCheckSequence，FCS)F形成n比特的传输帧T，再将其发送出去。