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，再將其發送出去。