迴圈冗餘校驗(CRC)演算法入門引導

NO IMAGE

寫給嵌入式程式設計師的迴圈冗餘校驗(CRC)演算法入門引導

前言

CRC校驗(迴圈冗餘校驗)是資料通訊中最常採用的校驗方式。在嵌入式軟體開發中,經常要用到CRC 演算法對各種資料進行校驗。因此,掌握基本的CRC演算法應是嵌入式程式設計師的基本技能。可是,我認識的嵌入式程式設計師中能真正掌握CRC演算法的人卻很少,平常在專案中見到的CRC的程式碼多數都是那種效率非常低下的實現方式。

其實,在網上有一篇介紹CRC 演算法的非常好的文章,作者是Ross Williams,題目叫:“A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS”。我常將這篇文章推薦給向我詢問CRC演算法的朋友,但不少朋友向我抱怨原文太長了,而且是英文的。希望我能寫篇短點的文章,因此就有了本文。不過,我的水平比不了Ross Williams,我的文章肯定也沒Ross Williams的寫的好。因此,閱讀英文沒有障礙的朋友還是去讀Ross Williams的原文吧。

本文的讀者群設定為軟體開發人員,尤其是從事嵌入式軟體開發的程式設計師,而不是專業從事數學或通訊領域研究的學者(我也沒有這個水平寫的這麼高深)。因此,本文的目標是介紹CRC演算法的基本原理和實現方式,用到的數學儘量控制在高中生可以理解的深度。

另外,鑑於大多數嵌入式程式設計師都是半路出家轉行過來的,不少人只會C語言。因此,文中的示例程式碼全部採用C語言來實現。作為一篇入門短文,文中給出的程式碼更注重於示範性,儘可能的保持易讀性。因此,文中的程式碼並不追求最高效的實現,但對於一般的應用卻也足夠快速了。

從奇偶校驗說起

所謂通訊過程的校驗是指在通訊資料後加上一些附加資訊,通過這些附加資訊來判斷接收到的資料是否和傳送出的資料相同。比如說RS232序列通訊可以設定奇偶校驗位,所謂奇偶校驗就是在傳送的每一個位元組後都加上一位,使得每個位元組中1的個數為奇數個或偶數個。比如我們要傳送的位元組是0x1a,二進位制表示為0001 1010。

採用奇校驗,則在資料後補上個0,資料變為0001 1010 0,資料中1的個數為奇數個(3個)

採用偶校驗,則在資料後補上個1,資料變為0001 1010 1,資料中1的個數為偶數個(4個)

接收方通過計算資料中1個數是否滿足奇偶性來確定資料是否有錯。

奇偶校驗的缺點也很明顯,首先,它對錯誤的檢測概率大約只有50%。也就是隻有一半的錯誤它能夠檢測出來。另外,每傳輸一個位元組都要附加一位校驗位,對傳輸效率的影響很大。因此,在高速資料通訊中很少採用奇偶校驗。奇偶校驗優點也很明顯,它很簡單,因此可以用硬體來實現,這樣可以減少軟體的負擔。因此,奇偶校驗也被廣泛的應用著。

奇偶校驗就先介紹到這來,之所以從奇偶校驗說起,是因為這種校驗方式最簡單,而且後面將會知道奇偶校驗其實就是CRC 校驗的一種(CRC-1)。

累加和校驗

另一種常見的校驗方式是累加和校驗。所謂累加和校驗實現方式有很多種,最常用的一種是在一次通訊資料包的最後加入一個位元組的校驗資料。這個位元組內容為前面資料包中全部資料的忽略進位的按位元組累加和。比如下面的例子:

我們要傳輸的資訊為: 6、23、4

加上校驗和後的資料包:6、23、4、33

這裡 33 為前三個位元組的校驗和。接收方收到全部資料後對前三個資料進行同樣的累加計算,如果累加和與最後一個位元組相同的話就認為傳輸的資料沒有錯誤。

累加和校驗由於實現起來非常簡單,也被廣泛的採用。但是這種校驗方式的檢錯能力也比較一般,對於單位元組的校驗和大概有1/256 的概率將原本是錯誤的通訊資料誤判為正確資料。之所以這裡介紹這種校驗,是因為CRC校驗在傳輸資料的形式上與累加和校驗是相同的,都可以表示為:通訊資料 校驗位元組(也可能是多個位元組)

初識 CRC 演算法

CRC 演算法的基本思想是將傳輸的資料當做一個位數很長的數。將這個數除以另一個數。得到的餘數作為校驗資料附加到原資料後面。還以上面例子中的資料為例:

6、23、4 可以看做一個2進位制數: 0000011000010111 00000010

假如被除數選9,二進位制表示為:1001

則除法運算可以表示為:

可以看到,最後的餘數為1。如果我們將這個餘數作為校驗和的話,傳輸的資料則是:6、23、4、1

CRC 演算法和這個過程有點類似,不過採用的不是上面例子中的通常的這種除法。在CRC演算法中,將二進位制資料流作為多項式的係數,然後進行的是多項式的乘除法。還是舉個例子吧。

比如說我們有兩個二進位制數,分別為:1101 和1011。

1101 與如下的多項式相聯絡:1x3 1x2 0x1 1x0=x3 x2 x0

1011與如下的多項式相聯絡:1x3 0x2 1x1 1x0=x3 x1 x0

兩個多項式的乘法:(x3 x2 x0)(x3 x1 x0)=x6 x5 x4 x3 x3 x3 x2 x1 x0

得到結果後,合併同類項時採用模2運算。也就是說乘除法採用正常的多項式乘除法,而加減法都採用模2運算。所謂模2運算就是結果除以2後取餘數。比如3 mod 2 = 1。因此,上面最終得到的多項式為:x6 x5 x4 x3 x2 x1 x0,對應的二進位制數:111111

加減法採用模2運算後其實就成了一種運算了,就是我們通常所說的異或運算:

0 0=0

0 1=1

1 0=1

1 1=0

0-0=0

1-0=1

0-1=1

1-1=0

上面說了半天多項式,其實就算是不引入多項式乘除法的概念也可以說明這些運算的特殊之處。只不過幾乎所有講解 CRC 演算法的文獻中都會提到多項式,因此這裡也簡單的寫了一點基本的概念。不過總用這種多項式表示也很羅嗦,下面的講解中將盡量採用更簡潔的寫法。

除法運算與上面給出的乘法概念類似,還是遇到加減的地方都用異或運算來代替。下面是一個例子:

要傳輸的資料為:1101011011

除數設為:10011

在計算前先將原始資料後面填上4個0:11010110110000,之所以要補0,後面再做解釋。

從這個例子可以看出,採用了模2的加減法後,不需要考慮借位的問題,所以除法變簡單了。最後得到的餘數就是CRC 校驗字。為了進行CRC運算,也就是這種特殊的除法運算,必須要指定個被除數,在CRC演算法中,這個被除數有一個專有名稱叫做“生成多項式”。生成多項式的選取是個很有難度的問題,如果選的不好,那麼檢出錯誤的概率就會低很多。好在這個問題已經被專家們研究了很長一段時間了,對於我們這些使用者來說,只要把現成的成果拿來用就行了。

最常用的幾種生成多項式如下:

CRC8=X8 X5 X4 X0

CRC-CCITT=X16 X12 X5 X0

CRC16=X16 X15 X2 X0

CRC12=X12 X11 X3 X2 X0

CRC32=X32 X26 X23 X22 X16 X12 X11 X10 X8 X7 X5 X4 X2 X1 X0

有一點要特別注意,文獻中提到的生成多項式經常會說到多項式的位寬(Width,簡記為W),這個位寬不是多項式對應的二進位制數的位數,而是位數減1。比如CRC8中用到的位寬為8的生成多項式,其實對應得二進位制數有九位:100110001。另外一點,多項式表示和二進位制表示都很繁瑣,交流起來不方便,因此,文獻中多用16進位制簡寫法來表示,因為生成多項式的最高位肯定為1,最高位的位置由位寬可知,故在簡記式中,將最高的1統一去掉了,如CRC32的生成多項式簡記為04C11DB7實際上表示的是104C11DB7。當然,這樣簡記除了方便外,在程式設計計算時也有它的用處。

對於上面的例子,位寬為4(W=4),按照CRC演算法的要求,計算前要在原始資料後填上W個0,也就是4個0。

位寬W=1的生成多項式(CRC1)有兩種,分別是X1和X1 X0,讀者可以自己證明10 對應的就是奇偶校驗中的奇校驗,而11對應則是偶校驗。因此,寫到這裡我們知道了奇偶校驗其實就是CRC校驗的一種特例,這也是我要以奇偶校驗作為開篇介紹的原因了。

CRC演算法的程式設計實現

說了這麼多總算到了核心部分了。從前面的介紹我們知道CRC校驗核心就是實現無借位的除法運算。下面還是通過一個例子來說明如何實現CRC校驗。

假設我們的生成多項式為:100110001(簡記為0x31),也就是CRC-8

則計算步驟如下:

(1)      將CRC暫存器(8-bits,比生成多項式少1bit)賦初值0

(2)      在待傳輸資訊流後面加入8個0

(3)      While (資料未處理完)

(4)      Begin

(5)          If (CRC暫存器首位是1)

(6)              reg = reg XOR 0x31

(7)          CRC暫存器左移一位,讀入一個新的資料於CRC暫存器的0 bit的位置。

(8)      End

(9)      CRC暫存器就是我們所要求的餘數。

 

實際上,真正的CRC 計算通常與上面描述的還有些出入。這是因為這種最基本的CRC除法有個很明顯的缺陷,就是資料流的開頭新增一些0並不影響最後校驗字的結果。這個問題很讓人惱火啊,因此真正應用的CRC 演算法基本都在原始的CRC演算法的基礎上做了些小的改動。

所謂的改動,也就是增加了兩個概念,第一個是“餘數初始值”,第二個是“結果異或值”。

所謂的“餘數初始值”就是在計算CRC值的開始,給CRC暫存器一個初始值。“結果異或值”是在其餘計算完成後將CRC暫存器的值在與這個值進行一下異或操作作為最後的校驗值。

常見的三種CRC 標準用到個各個引數如下表。

 

CCITT

CRC16

CRC32

校驗和位寬W

16

16

32

生成多項式

x16 x12 x5 1

x16 x15 x2 1

x32 x26 x23 x22 x16

x12 x11 x10 x8 x7 x5

x4 x2 x1 1

除數(多項式)

0x1021

0x8005

0x04C11DB7

餘數初始值

0xFFFF

0x0000

0xFFFFFFFF

結果異或值

0x0000

0x0000

0xFFFFFFFF

 

加入這些變形後,常見的演算法描述形式就成了這個樣子了:

(1)      設定CRC暫存器,並給其賦值為“餘數初始值”。

(2)      將資料的第一個8-bit字元與CRC暫存器進行異或,並把結果存入CRC暫存器。

(3)      CRC暫存器向右移一位,MSB補零,移出並檢查LSB。

(4)      如果LSB為0,重複第三步;若LSB為1,CRC暫存器與0x31相異或。

(5)      重複第3與第4步直到8次移位全部完成。此時一個8-bit資料處理完畢。

(6)      重複第2至第5步直到所有資料全部處理完成。

(7)      最終CRC暫存器的內容與“結果異或值”進行或非操作後即為CRC值。

 

示例性的C程式碼如下所示,因為效率很低,專案中如對計算時間有要求應該避免採用這樣的程式碼。不過這個程式碼已經比網上常見的計算程式碼要好了,因為這個程式碼有一個crc的引數,可以將上次計算的crc結果傳入函式中作為這次計算的初始值,這對大資料塊的CRC計算是很有用的,不需要一次將所有資料讀入記憶體,而是讀一部分算一次,全讀完後就計算完了。這對記憶體受限系統還是很有用的。

#define POLY        0x1021
/**
* Calculating CRC-16 in 'C'
* @para addr, start of data
* @para num, length of data
* @para crc, incoming CRC
*/
uint16_t crc16(unsigned char *addr, int num, uint16_t crc)
{
int i;
for (; num > 0; num--)              /* Step through bytes in memory */
{
crc = crc ^ (*addr   << 8);     /* Fetch byte from memory, XOR into CRC top byte*/
for (i = 0; i < 8; i  )             /* Prepare to rotate 8 bits */
{
if (crc & 0x8000)            /* b15 is set... */
crc = (crc << 1) ^ POLY;    /* rotate and XOR with polynomic */
else                          /* b15 is clear... */
crc <<= 1;                  /* just rotate */
}                             /* Loop for 8 bits */
crc &= 0xFFFF;                  /* Ensure CRC remains 16-bit value */
}                               /* Loop until num=0 */
return(crc);                    /* Return updated CRC */
}

上面的程式碼是我從http://mdfs.net/Info/Comp/Comms/CRC16.htm找到的,不過原始程式碼有錯誤,我做了些小的修改。

下面對這個函式給出個例子片段程式碼:

    unsigned char data1[] = {'1', '2', '3', '4', '5', '6', '7', '8', '9'};
unsigned char data2[] = {'5', '6', '7', '8', '9'};
unsigned short c1, c2;
c1 = crc16(data1, 9, 0xffff);
c2 = crc16(data1, 4, 0xffff);
c2 = crc16(data2, 5, c2);
printf("%04x\n", c1);
printf("%04x\n", c2);

讀者可以驗算,c1、c2 的結果都為 29b1。上面程式碼中crc 的初始值之所以為0xffff,是因為CCITT標準要求的除數初始值就是0xffff。

上面的演算法對資料流逐位進行計算,效率很低。實際上仔細分析CRC計算的數學性質後我們可以多位多位計算,最常用的是一種按位元組查表的快速演算法。該演算法基於這樣一個事實:計算本位元組後的CRC碼,等於上一位元組餘式CRC碼的低8位左移8位,加上上一位元組CRC右移 8位和本位元組之和後所求得的CRC碼。如果我們把8位二進位制序列數的CRC(共256個)全部計算出來,放在一個表裡,編碼時只要從表中查詢對應的值進行處理即可。

按照這個方法,可以有如下的程式碼(這個程式碼也不是我寫的,是我在Micbael Barr的書“Programming Embedded Systems in C and C ” 中找到的,同樣,我做了點小小的改動。):

/*
crc.h
*/
#ifndef CRC_H_INCLUDED
#define CRC_H_INCLUDED
/*
* The CRC parameters. Currently configured for CCITT.
* Simply modify these to switch to another CRC Standard.
*/
/*
#define POLYNOMIAL          0x8005
#define INITIAL_REMAINDER   0x0000
#define FINAL_XOR_VALUE     0x0000
*/
#define POLYNOMIAL          0x1021
#define INITIAL_REMAINDER   0xFFFF
#define FINAL_XOR_VALUE     0x0000
/*
#define POLYNOMIAL          0x1021
#define POLYNOMIAL          0xA001
#define INITIAL_REMAINDER   0xFFFF
#define FINAL_XOR_VALUE     0x0000
*/
/*
* The width of the CRC calculation and result.
* Modify the typedef for an 8 or 32-bit CRC standard.
*/
typedef unsigned short width_t;
#define WIDTH (8 * sizeof(width_t))
#define TOPBIT (1 << (WIDTH - 1))
/**
* Initialize the CRC lookup table.
* This table is used by crcCompute() to make CRC computation faster.
*/
void crcInit(void);
/**
* Compute the CRC checksum of a binary message block.
* @para message, 用來計算的資料
* @para nBytes, 資料的長度
* @note This function expects that crcInit() has been called
*       first to initialize the CRC lookup table.
*/
width_t crcCompute(unsigned char * message, unsigned int nBytes);
#endif // CRC_H_INCLUDED

 

/*
*crc.c
*/
#include "crc.h"
/*
* An array containing the pre-computed intermediate result for each
* possible byte of input. This is used to speed up the computation.
*/
static width_t crcTable[256];
/**
* Initialize the CRC lookup table.
* This table is used by crcCompute() to make CRC computation faster.
*/
void crcInit(void)
{
width_t remainder;
width_t dividend;
int bit;
/* Perform binary long division, a bit at a time. */
for(dividend = 0; dividend < 256; dividend  )
{
/* Initialize the remainder.  */
remainder = dividend << (WIDTH - 8);
/* Shift and XOR with the polynomial.   */
for(bit = 0; bit < 8; bit  )
{
/* Try to divide the current data bit.  */
if(remainder & TOPBIT)
{
remainder = (remainder << 1) ^ POLYNOMIAL;
}
else
{
remainder = remainder << 1;
}
}
/* Save the result in the table. */
crcTable[dividend] = remainder;
}
} /* crcInit() */
/**
* Compute the CRC checksum of a binary message block.
* @para message, 用來計算的資料
* @para nBytes, 資料的長度
* @note This function expects that crcInit() has been called
*       first to initialize the CRC lookup table.
*/
width_t crcCompute(unsigned char * message, unsigned int nBytes)
{
unsigned int offset;
unsigned char byte;
width_t remainder = INITIAL_REMAINDER;
/* Divide the message by the polynomial, a byte at a time. */
for( offset = 0; offset < nBytes; offset  )
{
byte = (remainder >> (WIDTH - 8)) ^ message[offset];
remainder = crcTable[byte] ^ (remainder << 8);
}
/* The final remainder is the CRC result. */
return (remainder ^ FINAL_XOR_VALUE);
} /* crcCompute() */

 

上面程式碼中crcInit() 函式用來計算crcTable,因此在呼叫 crcCompute 前必須先呼叫 crcInit()。不過,對於嵌入式系統,RAM是很緊張的,最好將 crcTable 提前算好,作為常量資料存到程式儲存區而不佔用RAM空間。CRC 計算實際上還有很多內容可以介紹,不過對於一般的程式設計師來說,知道這些也就差不多了。餘下的部分以後有時間了我再寫篇文章來介紹吧。

 

最後,給出個 C 程式碼,實現了 CRC8、CRC16 和 CRC32 的計算。收集了常見的各種 CRC 係數。 程式碼可以從這裡下載:https://code.csdn.net/liyuanbhu/crc_compute/tree/master

#ifndef CRCCOMPUTE_H
#define CRCCOMPUTE_H
#include <stdint.h>
template <typename TYPE> class CRC
{
public:
CRC();
CRC(TYPE polynomial, TYPE init_remainder, TYPE final_xor_value);
void build(TYPE polynomial, TYPE init_remainder, TYPE final_xor_value);
/**
* Compute the CRC checksum of a binary message block.
* @para message, 用來計算的資料
* @para nBytes, 資料的長度
*/
TYPE crcCompute(char * message, unsigned int nBytes);
TYPE crcCompute(char * message, unsigned int nBytes, bool reinit);
protected:
TYPE m_polynomial;
TYPE m_initial_remainder;
TYPE m_final_xor_value;
TYPE m_remainder;
TYPE crcTable[256];
int m_width;
int m_topbit;
/**
* Initialize the CRC lookup table.
* This table is used by crcCompute() to make CRC computation faster.
*/
void crcInit(void);
};
template <typename TYPE>
CRC<TYPE>::CRC()
{
m_width = 8 * sizeof(TYPE);
m_topbit = 1 << (m_width - 1);
}
template <typename TYPE>
CRC<TYPE>::CRC(TYPE polynomial, TYPE init_remainder, TYPE final_xor_value)
{
m_width = 8 * sizeof(TYPE);
m_topbit = 1 << (m_width - 1);
m_polynomial = polynomial;
m_initial_remainder = init_remainder;
m_final_xor_value = final_xor_value;
crcInit();
}
template <typename TYPE>
void CRC<TYPE>::build(TYPE polynomial, TYPE init_remainder, TYPE final_xor_value)
{
m_polynomial = polynomial;
m_initial_remainder = init_remainder;
m_final_xor_value = final_xor_value;
crcInit();
}
template <typename TYPE>
TYPE CRC<TYPE>::crcCompute(char * message, unsigned int nBytes)
{
unsigned int offset;
unsigned char byte;
TYPE remainder = m_initial_remainder;
/* Divide the message by the polynomial, a byte at a time. */
for( offset = 0; offset < nBytes; offset  )
{
byte = (remainder >> (m_width - 8)) ^ message[offset];
remainder = crcTable[byte] ^ (remainder << 8);
}
/* The final remainder is the CRC result. */
return (remainder ^ m_final_xor_value);
}
template <typename TYPE>
TYPE CRC<TYPE>::crcCompute(char * message, unsigned int nBytes, bool reinit)
{
unsigned int offset;
unsigned char byte;
if(reinit)
{
m_remainder = m_initial_remainder;
}
/* Divide the message by the polynomial, a byte at a time. */
for( offset = 0; offset < nBytes; offset  )
{
byte = (m_remainder >> (m_width - 8)) ^ message[offset];
m_remainder = crcTable[byte] ^ (m_remainder << 8);
}
/* The final remainder is the CRC result. */
return (m_remainder ^ m_final_xor_value);
}
class CRC8 : public CRC<uint8_t>
{
public:
enum CRC8_TYPE {eCRC8, eAUTOSAR, eCDMA2000, eDARC, eDVB_S2, eEBU, eAES, eGSM_A, eGSM_B, eI_CODE,
eITU, eLTE, eMAXIM, eOPENSAFETY, eROHC, eSAE_J1850, eWCDMA};
CRC8(CRC8_TYPE type);
CRC8(uint8_t polynomial, uint8_t init_remainder, uint8_t final_xor_value)
:CRC<uint8_t>(polynomial, init_remainder, final_xor_value){}
};
class CRC16 : public CRC<uint16_t>
{
public:
enum CRC16_TYPE {eCCITT, eKERMIT, eCCITT_FALSE, eIBM, eARC, eLHA, eSPI_FUJITSU,
eBUYPASS, eVERIFONE, eUMTS, eCDMA2000, eCMS, eDDS_110, eDECT_R,
eDECT_X, eDNP, eEN_13757, eGENIBUS, eEPC, eDARC, eI_CODE, eGSM,
eLJ1200, eMAXIM, eMCRF4XX, eOPENSAFETY_A, eOPENSAFETY_B, ePROFIBUS,
eIEC_61158_2, eRIELLO, eT10_DIF, eTELEDISK, eTMS37157, eUSB,
eCRC_A, eMODBUS, eX_25, eCRC_B, eISO_HDLC, eIBM_SDLC, eXMODEM,
eZMODEM, eACORN, eLTE};
CRC16(CRC16_TYPE type);
CRC16(uint16_t polynomial, uint16_t init_remainder, uint16_t final_xor_value)
:CRC<uint16_t>(polynomial, init_remainder, final_xor_value){}
};
class CRC32 : public CRC<uint32_t>
{
public:
enum CRC32_TYPE {eADCCP, ePKZIP, eCRC32, eAAL5, eDECT_B, eB_CRC32, eBZIP2, eAUTOSAR,
eCRC32C, eCRC32D, eMPEG2, ePOSIX, eCKSUM, eCRC32Q, eJAMCRC, eXFER};
CRC32(CRC32_TYPE type);
};
#endif // CRCCOMPUTE_H

#include "crcCompute.h"
template <typename TYPE>
void CRC<TYPE>::crcInit(void)
{
TYPE remainder;
TYPE dividend;
int bit;
/* Perform binary long division, a bit at a time. */
for(dividend = 0; dividend < 256; dividend  )
{
/* Initialize the remainder.  */
remainder = dividend << (m_width - 8);
/* Shift and XOR with the polynomial.   */
for(bit = 0; bit < 8; bit  )
{
/* Try to divide the current data bit.  */
if(remainder & m_topbit)
{
remainder = (remainder << 1) ^ m_polynomial;
}
else
{
remainder = remainder << 1;
}
}
/* Save the result in the table. */
crcTable[dividend] = remainder;
}
}
CRC8::CRC8(CRC8_TYPE type)
{
switch (type)
{
case eCRC8:
m_polynomial = 0x07; //http://reveng.sourceforge.net/crc-catalogue/all.htm
m_initial_remainder = 0x00;
m_final_xor_value = 0x00;
break;
case eAUTOSAR:
m_polynomial = 0x2f;
m_initial_remainder = 0xff;
m_final_xor_value = 0xff;
break;
case eCDMA2000:
m_polynomial = 0x9b;
m_initial_remainder = 0xFF;
m_final_xor_value = 0x00;
break;
case eDARC:
m_polynomial = 0x39;
m_initial_remainder = 0x00;
m_final_xor_value = 0x00;
break;
case eDVB_S2:
m_polynomial = 0xd5;
m_initial_remainder = 0x00;
m_final_xor_value = 0x00;
break;
case eEBU:
case eAES:
m_polynomial = 0x1d;
m_initial_remainder = 0xFF;
m_final_xor_value = 0x00;
break;
case eGSM_A:
m_polynomial = 0x1d;
m_initial_remainder = 0x00;
m_final_xor_value = 0x00;
break;
case eGSM_B:
m_polynomial = 0x49;
m_initial_remainder = 0x00;
m_final_xor_value = 0xFF;
break;
case eI_CODE:
m_polynomial = 0x1d;
m_initial_remainder = 0xFD;
m_final_xor_value = 0x00;
break;
case eITU:
m_polynomial = 0x07;
m_initial_remainder = 0x00;
m_final_xor_value = 0x55;
break;
case eLTE:
m_polynomial = 0x9b;
m_initial_remainder = 0x00;
m_final_xor_value = 0x00;
break;
case eMAXIM:
m_polynomial = 0x31;
m_initial_remainder = 0x00;
m_final_xor_value = 0x00;
break;
case eOPENSAFETY:
m_polynomial = 0x2f;
m_initial_remainder = 0x00;
m_final_xor_value = 0x00;
break;
case eROHC:
m_polynomial = 0x07;
m_initial_remainder = 0xff;
m_final_xor_value = 0x00;
break;
case eSAE_J1850:
m_polynomial = 0x1d;
m_initial_remainder = 0xff;
m_final_xor_value = 0xff;
break;
case eWCDMA:
m_polynomial = 0x9b;
m_initial_remainder = 0x00;
m_final_xor_value = 0x00;
break;
default:
m_polynomial = 0x07;
m_initial_remainder = 0x00;
m_final_xor_value = 0x00;
break;
}
crcInit();
}
CRC16::CRC16(CRC16_TYPE type)
{
switch (type)
{
case eCCITT_FALSE:
case eMCRF4XX:
m_polynomial = 0x1021;
m_initial_remainder = 0xFFFF;
m_final_xor_value = 0x0000;
break;
case eIBM:
case eARC:
case eLHA:
case eBUYPASS:
case eVERIFONE:
case eUMTS:
m_polynomial = 0x8005;
m_initial_remainder = 0x0000;
m_final_xor_value = 0x0000;
break;
case eSPI_FUJITSU:
m_polynomial = 0x1021;
m_initial_remainder = 0x1d0f;
m_final_xor_value = 0x0000;
break;
case eCCITT:
case eKERMIT:
case eXMODEM:
case eZMODEM:
case eACORN:
case eLTE:
m_polynomial = 0x1021;
m_initial_remainder = 0x0000;
m_final_xor_value = 0x0000;
break;
case eCDMA2000:
m_polynomial = 0xc867;
m_initial_remainder = 0xffff;
m_final_xor_value = 0x0000;
break;
case eCMS:
case eMODBUS:
m_polynomial = 0x8005;
m_initial_remainder = 0xffff;
m_final_xor_value = 0x0000;
break;
case eDDS_110:
m_polynomial = 0x8005;
m_initial_remainder = 0x800d;
m_final_xor_value = 0x0000;
break;
case eDECT_R:
m_polynomial = 0x0589;
m_initial_remainder = 0x0000;
m_final_xor_value = 0x0001;
break;
case eDECT_X:
m_polynomial = 0x0589;
m_initial_remainder = 0x0000;
m_final_xor_value = 0x0000;
break;
case eDNP:
case eEN_13757:
m_polynomial = 0x3d65;
m_initial_remainder = 0x0000;
m_final_xor_value = 0xffff;
break;
case eGENIBUS:
case eEPC:
case eDARC:
case eI_CODE:
case eX_25:
case eCRC_B:
case eISO_HDLC:
case eIBM_SDLC:
m_polynomial = 0x1021;
m_initial_remainder = 0xffff;
m_final_xor_value = 0xffff;
break;
case eGSM:
m_polynomial = 0x1021;
m_initial_remainder = 0x0000;
m_final_xor_value = 0xffff;
break;
case eLJ1200:
m_polynomial = 0x6f63;
m_initial_remainder = 0x0000;
m_final_xor_value = 0x0000;
break;
case eMAXIM:
m_polynomial = 0x8005;
m_initial_remainder = 0x0000;
m_final_xor_value = 0xffff;
break;
case eOPENSAFETY_A:
m_polynomial = 0x5935;
m_initial_remainder = 0x0000;
m_final_xor_value = 0x0000;
break;
case eOPENSAFETY_B:
m_polynomial = 0x755b;
m_initial_remainder = 0x0000;
m_final_xor_value = 0x0000;
break;
case ePROFIBUS:
case eIEC_61158_2:
m_polynomial = 0x1dcf;
m_initial_remainder = 0xffff;
m_final_xor_value = 0xffff;
break;
case eRIELLO:
m_polynomial = 0x1021;
m_initial_remainder = 0xb2aa;
m_final_xor_value = 0x0000;
break;
case eT10_DIF:
m_polynomial = 0x8bb7;
m_initial_remainder = 0x0000;
m_final_xor_value = 0x0000;
break;
case eTELEDISK:
m_polynomial = 0xa097;
m_initial_remainder = 0x0000;
m_final_xor_value = 0x0000;
break;
case eTMS37157:
m_polynomial = 0x1021;
m_initial_remainder = 0x89ec;
m_final_xor_value = 0x0000;
break;
case eUSB:
m_polynomial = 0x8005;
m_initial_remainder = 0xffff;
m_final_xor_value = 0xffff;
break;
case eCRC_A:
m_polynomial = 0x1021;
m_initial_remainder = 0xc6c6;
m_final_xor_value = 0x0000;
break;
default:
m_polynomial = 0x8005;
m_initial_remainder = 0x0000;
m_final_xor_value = 0x0000;
break;
}
crcInit();
}
CRC32::CRC32(CRC32_TYPE type)
{
switch (type)
{
case eADCCP:
case ePKZIP:
case eCRC32:
case eBZIP2:
case eAAL5:
case eDECT_B:
case eB_CRC32:
m_polynomial = 0x04c11db7;
m_initial_remainder = 0xFFFFFFFF;
m_final_xor_value = 0xFFFFFFFF;
break;
case eAUTOSAR:
m_polynomial = 0xf4acfb13;
m_initial_remainder = 0xFFFFFFFF;
m_final_xor_value = 0xFFFFFFFF;
break;
case eCRC32C:
m_polynomial = 0x1edc6f41;
m_initial_remainder = 0xFFFFFFFF;
m_final_xor_value = 0xFFFFFFFF;
break;
case eCRC32D:
m_polynomial = 0xa833982b;
m_initial_remainder = 0xFFFFFFFF;
m_final_xor_value = 0xFFFFFFFF;
break;
case eMPEG2:
case eJAMCRC:
m_polynomial = 0x04c11db7;
m_initial_remainder = 0xFFFFFFFF;
m_final_xor_value = 0x00000000;
break;
case ePOSIX:
case eCKSUM:
m_polynomial = 0x04c11db7;
m_initial_remainder = 0x00000000;
m_final_xor_value = 0xFFFFFFFF;
break;
case eCRC32Q:
m_polynomial = 0x814141ab;
m_initial_remainder = 0x00000000;
m_final_xor_value = 0x00000000;
break;
case eXFER:
m_polynomial = 0x000000af;
m_initial_remainder = 0x00000000;
m_final_xor_value = 0x00000000;
break;
default:
m_polynomial = 0x04C11DB7;
m_initial_remainder = 0xFFFFFFFF;
m_final_xor_value = 0xFFFFFFFF;
break;
}
crcInit();
}

#include <iostream>
#include <stdio.h>
#include "crcCompute.h"
using namespace std;
int main(int argc, char *argv[])
{
CRC16 crc16(CRC16::eCCITT_FALSE);
char data1[] = {'1', '2', '3', '4', '5', '6', '7', '8', '9'};
char data2[] = {'5', '6', '7', '8', '9'};
unsigned short c1, c2;
c1 = crc16.crcCompute(data1, 9);
c2 = crc16.crcCompute(data1, 4, true);
c2 = crc16.crcCompute(data2, 5, false);
printf("%04x\n", c1);
printf("%04x\n", c2);
return 0;
}