CRC——CRC16常见几个标准的算法及C语言实现

最新推荐文章于 2024-04-30 11:31:44 发布
最新推荐文章于 2024-04-30 11:31:44 发布
阅读量3k 收藏 21
点赞数 2
分类专栏： 工具 文章标签： CRC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN131137/article/details/103292950
版权

CRC16常见的标准有以下几种，被用在各个规范中，其算法原理基本一致，就是在数据的输入和输出有所差异，下边把这些标准的差异列出，并给出C语言的算法实现。

CRC16_CCITT：多项式x16+x12+x5+1（0x1021），初始值0x0000，低位在前，高位在后，结果与0x0000异或

CRC16_CCITT_FALSE：多项式x16+x12+x5+1（0x1021），初始值0xFFFF，低位在后，高位在前，结果与0x0000异或

CRC16_XMODEM：多项式x16+x12+x5+1（0x1021），初始值0x0000，低位在后，高位在前，结果与0x0000异或

CRC16_X25：多项式x16+x12+x5+1（0x1021），初始值0x0000，低位在前，高位在后，结果与0xFFFF异或

CRC16_MODBUS：多项式x16+x15+x2+1（0x8005），初始值0xFFFF，低位在前，高位在后，结果与0x0000异或

CRC16_IBM：多项式x16+x15+x2+1（0x8005），初始值0x0000，低位在前，高位在后，结果与0x0000异或

CRC16_MAXIM：多项式x16+x15+x2+1（0x8005），初始值0x0000，低位在前，高位在后，结果与0xFFFF异或

CRC16_USB：多项式x16+x15+x2+1（0x8005），初始值0xFFFF，低位在前，高位在后，结果与0xFFFF异或

模式

多项式

初始值

数据位序

结果处理

CRC16_CCITT

x16+x12+x5+1（0x1021）

0x0000

低位在前，高位在后

与0x0000异或

CRC16_CCITT_FALSE

x16+x12+x5+1（0x1021）

0xFFFF

低位在后，高位在前

与0x0000异或

CRC16_XMODEM

x16+x12+x5+1（0x1021）

0x0000

低位在后，高位在前

与0x0000异或

CRC16_X25

x16+x12+x5+1（0x1021）

0x0000

低位在后，高位在前

与0xFFFF异或

CRC16_ MODBUS

x16+x15+x2+1（0x8005）

0xFFFF

低位在前，高位在后

与0x0000异或

CRC16_ IBM

x16+x15+x2+1（0x8005）

0x0000

低位在前，高位在后

与0x0000异或

CRC16_ MAXIM

x16+x15+x2+1（0x8005）

0x0000

低位在前，高位在后

与0xFFFF异或

CRC16_ USB

x16+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校验码。

根据算法原理与标准要求就能简单的写出具体程序：


  
  
  1. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      unsigned short CRC16_CCITT(unsigned char *puchMsg, unsigned int usDataLen)
     
     
    
    
    
  2. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  3. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCRCin = 
      
      0x0000;
     
     
    
    
    
  4. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCPoly = 
      
      0x1021;
     
     
    
    
    
  5. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      char wChar = 
      
      0;
     
     
    
    
    
  6. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
     
     
    
    
    
  7. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      while (usDataLen--) 	
     
     
    
    
    
  8. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        {
     
     
    
    
    
  9. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wChar = *(puchMsg++);
     
     
    
    
    
  10. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              InvertUint8(&wChar,&wChar);
     
     
    
    
    
  11. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wCRCin ^= (wChar << 
      
      8);
     
     
    
    
    
  12. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
            
      
      for(
      
      int i = 
      
      0;i < 
      
      8;i++)
     
     
    
    
    
  13. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              {
     
     
    
    
    
  14. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      if(wCRCin & 
      
      0x8000)
     
     
    
    
    
  15. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = (wCRCin << 
      
      1) ^ wCPoly;
     
     
    
    
    
  16. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      else
     
     
    
    
    
  17. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = wCRCin << 
      
      1;
     
     
    
    
    
  18. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              }
     
     
    
    
    
  19. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        }
     
     
    
    
    
  20. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        InvertUint16(&wCRCin,&wCRCin);
     
     
    
    
    
  21. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      return (wCRCin) ;
     
     
    
    
    
  22. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    
  23. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      unsigned short CRC16_CCITT_FALSE(unsigned char *puchMsg, unsigned int usDataLen)
     
     
    
    
    
  24. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  25. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCRCin = 
      
      0xFFFF;
     
     
    
    
    
  26. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCPoly = 
      
      0x1021;
     
     
    
    
    
  27. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      char wChar = 
      
      0;
     
     
    
    
    
  28. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
     
     
    
    
    
  29. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      while (usDataLen--) 	
     
     
    
    
    
  30. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        {
     
     
    
    
    
  31. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wChar = *(puchMsg++);
     
     
    
    
    
  32. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wCRCin ^= (wChar << 
      
      8);
     
     
    
    
    
  33. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
            
      
      for(
      
      int i = 
      
      0;i < 
      
      8;i++)
     
     
    
    
    
  34. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              {
     
     
    
    
    
  35. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      if(wCRCin & 
      
      0x8000)
     
     
    
    
    
  36. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = (wCRCin << 
      
      1) ^ wCPoly;
     
     
    
    
    
  37. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      else
     
     
    
    
    
  38. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = wCRCin << 
      
      1;
     
     
    
    
    
  39. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              }
     
     
    
    
    
  40. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        }
     
     
    
    
    
  41. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      return (wCRCin) ;
     
     
    
    
    
  42. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    
  43. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      unsigned short CRC16_XMODEM(unsigned char *puchMsg, unsigned int usDataLen)
     
     
    
    
    
  44. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  45. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCRCin = 
      
      0x0000;
     
     
    
    
    
  46. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCPoly = 
      
      0x1021;
     
     
    
    
    
  47. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      char wChar = 
      
      0;
     
     
    
    
    
  48. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
     
     
    
    
    
  49. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      while (usDataLen--) 	
     
     
    
    
    
  50. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        {
     
     
    
    
    
  51. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wChar = *(puchMsg++);
     
     
    
    
    
  52. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wCRCin ^= (wChar << 
      
      8);
     
     
    
    
    
  53. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
            
      
      for(
      
      int i = 
      
      0;i < 
      
      8;i++)
     
     
    
    
    
  54. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              {
     
     
    
    
    
  55. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      if(wCRCin & 
      
      0x8000)
     
     
    
    
    
  56. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = (wCRCin << 
      
      1) ^ wCPoly;
     
     
    
    
    
  57. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      else
     
     
    
    
    
  58. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = wCRCin << 
      
      1;
     
     
    
    
    
  59. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              }
     
     
    
    
    
  60. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        }
     
     
    
    
    
  61. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      return (wCRCin) ;
     
     
    
    
    
  62. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    
  63. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
     
     
     
    
    
    
  64. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      unsigned short CRC16_X25(unsigned char *puchMsg, unsigned int usDataLen)
     
     
    
    
    
  65. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  66. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCRCin = 
      
      0xFFFF;
     
     
    
    
    
  67. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCPoly = 
      
      0x1021;
     
     
    
    
    
  68. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      char wChar = 
      
      0;
     
     
    
    
    
  69. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
     
     
    
    
    
  70. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      while (usDataLen--) 	
     
     
    
    
    
  71. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        {
     
     
    
    
    
  72. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wChar = *(puchMsg++);
     
     
    
    
    
  73. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              InvertUint8(&wChar,&wChar);
     
     
    
    
    
  74. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wCRCin ^= (wChar << 
      
      8);
     
     
    
    
    
  75. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
            
      
      for(
      
      int i = 
      
      0;i < 
      
      8;i++)
     
     
    
    
    
  76. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              {
     
     
    
    
    
  77. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      if(wCRCin & 
      
      0x8000)
     
     
    
    
    
  78. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = (wCRCin << 
      
      1) ^ wCPoly;
     
     
    
    
    
  79. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      else
     
     
    
    
    
  80. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = wCRCin << 
      
      1;
     
     
    
    
    
  81. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              }
     
     
    
    
    
  82. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        }
     
     
    
    
    
  83. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        InvertUint16(&wCRCin,&wCRCin);
     
     
    
    
    
  84. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      return (wCRCin^
      
      0xFFFF) ;
     
     
    
    
    
  85. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    
  86. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
     
     
     
    
    
    
  87. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      unsigned short CRC16_MODBUS(unsigned char *puchMsg, unsigned int usDataLen)
     
     
    
    
    
  88. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  89. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCRCin = 
      
      0xFFFF;
     
     
    
    
    
  90. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCPoly = 
      
      0x8005;
     
     
    
    
    
  91. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      char wChar = 
      
      0;
     
     
    
    
    
  92. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
     
     
    
    
    
  93. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      while (usDataLen--) 	
     
     
    
    
    
  94. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        {
     
     
    
    
    
  95. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wChar = *(puchMsg++);
     
     
    
    
    
  96. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              InvertUint8(&wChar,&wChar);
     
     
    
    
    
  97. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wCRCin ^= (wChar << 
      
      8);
     
     
    
    
    
  98. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
            
      
      for(
      
      int i = 
      
      0;i < 
      
      8;i++)
     
     
    
    
    
  99. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              {
     
     
    
    
    
  100. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      if(wCRCin & 
      
      0x8000)
     
     
    
    
    
  101. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = (wCRCin << 
      
      1) ^ wCPoly;
     
     
    
    
    
  102. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      else
     
     
    
    
    
  103. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = wCRCin << 
      
      1;
     
     
    
    
    
  104. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              }
     
     
    
    
    
  105. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        }
     
     
    
    
    
  106. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        InvertUint16(&wCRCin,&wCRCin);
     
     
    
    
    
  107. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      return (wCRCin) ;
     
     
    
    
    
  108. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    
  109. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      unsigned short CRC16_IBM(unsigned char *puchMsg, unsigned int usDataLen)
     
     
    
    
    
  110. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  111. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCRCin = 
      
      0x0000;
     
     
    
    
    
  112. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCPoly = 
      
      0x8005;
     
     
    
    
    
  113. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      char wChar = 
      
      0;
     
     
    
    
    
  114. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
     
     
    
    
    
  115. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      while (usDataLen--) 	
     
     
    
    
    
  116. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        {
     
     
    
    
    
  117. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wChar = *(puchMsg++);
     
     
    
    
    
  118. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              InvertUint8(&wChar,&wChar);
     
     
    
    
    
  119. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wCRCin ^= (wChar << 
      
      8);
     
     
    
    
    
  120. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
            
      
      for(
      
      int i = 
      
      0;i < 
      
      8;i++)
     
     
    
    
    
  121. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              {
     
     
    
    
    
  122. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      if(wCRCin & 
      
      0x8000)
     
     
    
    
    
  123. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = (wCRCin << 
      
      1) ^ wCPoly;
     
     
    
    
    
  124. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      else
     
     
    
    
    
  125. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = wCRCin << 
      
      1;
     
     
    
    
    
  126. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              }
     
     
    
    
    
  127. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        }
     
     
    
    
    
  128. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        InvertUint16(&wCRCin,&wCRCin);
     
     
    
    
    
  129. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      return (wCRCin) ;
     
     
    
    
    
  130. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    
  131. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      unsigned short CRC16_MAXIM(unsigned char *puchMsg, unsigned int usDataLen)
     
     
    
    
    
  132. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  133. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCRCin = 
      
      0x0000;
     
     
    
    
    
  134. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCPoly = 
      
      0x8005;
     
     
    
    
    
  135. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      char wChar = 
      
      0;
     
     
    
    
    
  136. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
     
     
    
    
    
  137. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      while (usDataLen--) 	
     
     
    
    
    
  138. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        {
     
     
    
    
    
  139. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wChar = *(puchMsg++);
     
     
    
    
    
  140. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              InvertUint8(&wChar,&wChar);
     
     
    
    
    
  141. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wCRCin ^= (wChar << 
      
      8);
     
     
    
    
    
  142. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
            
      
      for(
      
      int i = 
      
      0;i < 
      
      8;i++)
     
     
    
    
    
  143. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              {
     
     
    
    
    
  144. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      if(wCRCin & 
      
      0x8000)
     
     
    
    
    
  145. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = (wCRCin << 
      
      1) ^ wCPoly;
     
     
    
    
    
  146. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      else
     
     
    
    
    
  147. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = wCRCin << 
      
      1;
     
     
    
    
    
  148. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              }
     
     
    
    
    
  149. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        }
     
     
    
    
    
  150. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        InvertUint16(&wCRCin,&wCRCin);
     
     
    
    
    
  151. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      return (wCRCin^
      
      0xFFFF) ;
     
     
    
    
    
  152. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    
  153. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      unsigned short CRC16_USB(unsigned char *puchMsg, unsigned int usDataLen)
     
     
    
    
    
  154. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  155. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCRCin = 
      
      0xFFFF;
     
     
    
    
    
  156. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      short wCPoly = 
      
      0x8005;
     
     
    
    
    
  157. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      unsigned 
      
      char wChar = 
      
      0;
     
     
    
    
    
  158. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
     
     
    
    
    
  159. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      while (usDataLen--) 	
     
     
    
    
    
  160. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        {
     
     
    
    
    
  161. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wChar = *(puchMsg++);
     
     
    
    
    
  162. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              InvertUint8(&wChar,&wChar);
     
     
    
    
    
  163. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wCRCin ^= (wChar << 
      
      8);
     
     
    
    
    
  164. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
            
      
      for(
      
      int i = 
      
      0;i < 
      
      8;i++)
     
     
    
    
    
  165. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              {
     
     
    
    
    
  166. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      if(wCRCin & 
      
      0x8000)
     
     
    
    
    
  167. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = (wCRCin << 
      
      1) ^ wCPoly;
     
     
    
    
    
  168. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
              
      
      else
     
     
    
    
    
  169. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = wCRCin << 
      
      1;
     
     
    
    
    
  170. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              }
     
     
    
    
    
  171. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        }
     
     
    
    
    
  172. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        InvertUint16(&wCRCin,&wCRCin);
     
     
    
    
    
  173. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
      
      
      return (wCRCin^
      
      0xFFFF) ;
     
     
    
    
    
  174. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    

  
  

  
  
  1. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      void InvertUint8(unsigned char *dBuf,unsigned char *srcBuf)
     
     
    
    
    
  2. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  3. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          
      
      int i;
     
     
    
    
    
  4. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          
      
      unsigned 
      
      char tmp[
      
      4];
     
     
    
    
    
  5. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          tmp[
      
      0] = 
      
      0;
     
     
    
    
    
  6. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          
      
      for(i=
      
      0;i< 
      
      8;i++)
     
     
    
    
    
  7. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          {
     
     
    
    
    
  8. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
            
      
      if(srcBuf[
      
      0]& (
      
      1 << i))
     
     
    
    
    
  9. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              tmp[
      
      0]|=
      
      1<<(
      
      7-i);
     
     
    
    
    
  10. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          }
     
     
    
    
    
  11. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          dBuf[
      
      0] = tmp[
      
      0];
     
     
    
    
    
  12. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          
     
     
    
    
    
  13. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    
  14. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      void InvertUint16(unsigned short *dBuf,unsigned short *srcBuf)
     
     
    
    
    
  15. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  16. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          
      
      int i;
     
     
    
    
    
  17. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          
      
      unsigned 
      
      short tmp[
      
      4];
     
     
    
    
    
  18. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          tmp[
      
      0] = 
      
      0;
     
     
    
    
    
  19. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          
      
      for(i=
      
      0;i< 
      
      16;i++)
     
     
    
    
    
  20. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          {
     
     
    
    
    
  21. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
            
      
      if(srcBuf[
      
      0]& (
      
      1 << i))
     
     
    
    
    
  22. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              tmp[
      
      0]|=
      
      1<<(
      
      15 - i);
     
     
    
    
    
  23. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          }
     
     
    
    
    
  24. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          dBuf[
      
      0] = tmp[
      
      0];
     
     
    
    
    
  25. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    
  26. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      void InvertUint32(unsigned int *dBuf,unsigned int *srcBuf)
     
     
    
    
    
  27. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  28. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          
      
      int i;
     
     
    
    
    
  29. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          
      
      unsigned 
      
      int tmp[
      
      4];
     
     
    
    
    
  30. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
     
     
     
    
    
    
  31. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          tmp[
      
      0] = 
      
      0;
     
     
    
    
    
  32. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          
     
     
    
    
    
  33. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          
      
      for(i=
      
      0;i< 
      
      32;i++)
     
     
    
    
    
  34. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          {
     
     
    
    
    
  35. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
            
      
      if(srcBuf[
      
      0]& (
      
      1 << i))
     
     
    
    
    
  36. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              tmp[
      
      0]|=
      
      1<<(
      
      15 - i);
     
     
    
    
    
  37. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          }
     
     
    
    
    
  38. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
          dBuf[
      
      0] = tmp[
      
      0];
     
     
    
    
    
  39. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    
  40.

具体验证使用这个工具，内含CRC算法的计算，和后边的博客中提到的其他算法的工具合集

加密解密算法工具集

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


  
  
  1. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      //CRC32算法：
     
     
    
    
    
  2. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      unsigned int CRC32(unsigned char *puchMsg, unsigned int usDataLen)
     
     
    
    
    
  3. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      {
     
     
    
    
    
  4. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        int i;
     
     
    
    
    
  5. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        unsigned int wCRCin = 0xFFFFFFFF;
     
     
    
    
    
  6. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        unsigned int wCPoly = 0x04C11DB7;
     
     
    
    
    
  7. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        unsigned int wChar = 0;
     
     
    
    
    
  8. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        while (usDataLen--) 	
     
     
    
    
    
  9. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        {
     
     
    
    
    
  10. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wChar = *(puchMsg++);
     
     
    
    
    
  11. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              InvertUint8((unsigned char *)&wChar,(unsigned char *)&wChar);
     
     
    
    
    
  12. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              wCRCin ^= (wChar 
      
      << 24);
     
     
    
    
    
  13. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              for(i = 0;i < 8;i++)
     
     
    
    
    
  14. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              {
     
     
    
    
    
  15. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                if(wCRCin & 0x80000000)
     
     
    
    
    
  16. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = (wCRCin << 1) ^ wCPoly;
     
     
    
    
    
  17. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                else
     
     
    
    
    
  18. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
                  wCRCin = wCRCin << 1;
     
     
    
    
    
  19. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
              }
     
     
    
    
    
  20. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        }
     
     
    
    
    
  21. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        InvertUint32(&wCRCin,&wCRCin);
     
     
    
    
    
  22. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
        return (wCRCin ^ 0xFFFFFFFF) ;
     
     
    
    
    
  23. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      }
     
     
    
    
    
  24.
对于CRC32可能还有其他的多项式和初始值和结果值是否需要异或以及输入数据是否需要位序倒转等要求在源码中修改


一、CRC16校验码的使用

　　现选择最常用的CRC-16校验，说明它的使用方法。

　　根据Modbus协议，常规485通讯的信息发送形式如下：

　　地址 功能码 数据信息 校验码

　　1byte 1byte nbyte 2byte

　　CRC校验是前面几段数据内容的校验值，为一个16位数据，发送时，低8位在前，高8为最后。

　　例如：信息字段代码为： 1011001，校验字段为：1010。

　　发送方：发出的传输字段为： 1 0 1 1 0 0 1 1 0 10

　　信息字段 校验字段

　　接收方：使用相同的计算方法计算出信息字段的校验码，对比接收到的实际校验码，如果相等及信息正确，不相等则信息错误；或者将接受到的所有信息除多项式，如果能够除尽，则信息正确。

二、CRC16校验码计算方法

　　常用查表法和计算法。计算方法一般都是：

　　（1）、预置1个16位的寄存器值0xFFFF，称此寄存器为CRC寄存器；

　　（2）、把第一个8位二进制数据（既通讯信息帧的第一个字节）与16位的CRC寄存器的低

　　8位相异或，把结果放于CRC寄存器，高八位数据不变；

　　（3）、把CRC寄存器的内容右移一位（朝高位）用0填补最高位，并检查右移后的移出位；

　　（4）、如果移出位为0：重复第3步（再次右移一位）；如果移出位为1，CRC寄存器与一多

　　项式（A001）进行异或；

　　（5）、重复步骤3和4，直到右移8次，这样整个8位数据全部进行了处理；

　　（6）、重复步骤2到步骤5，进行通讯信息帧下一个字节的处理；

　　（7）、将该通讯信息帧所有字节按上述步骤计算完成后，得到的16位CRC寄存器的高、低

　　字节进行交换；

　　（8）、最后得到的CRC寄存器内容即为：CRC码。

　　以上计算步骤中的多项式A001是8005按位颠倒后的结果。

　　查表法是将移位异或的计算结果做成了一个表，就是将0~256放入一个长度为16位的寄存器中的低八位，高八位填充0，然后将该寄存器与多项式0XA001按照上述3、4步骤，直到八位全部移出，最后寄存器中的值就是表格中的数据，高八位、低八位分别单独一个表。

三、CRC16常见几个标准的算法

　　CRC16常见的标准有以下几种，被用在各个规范中，其算法原理基本一致，就是在数据的输入和输出有所差异，下边把这些标准的差异列出，并给出C语言的算法实现。

　　CRC16_CCITT：多项式x16+x12+x5+1（0x1021），初始值0x0000，低位在前，高位在后，结果与0x0000异或

　　CRC16_CCITT_FALSE：多项式x16+x12+x5+1（0x1021），初始值0xFFFF，低位在后，高位在前，结果与0x0000异或

　　CRC16_XMODEM：多项式x16+x12+x5+1（0x1021），初始值0x0000，低位在后，高位在前，结果与0x0000异或

　　CRC16_X25：多项式x16+x12+x5+1（0x1021），初始值0x0000，低位在前，高位在后，结果与0xFFFF异或

　　CRC16_MODBUS：多项式x16+x15+x5+1（0x8005），初始值0xFFFF，低位在前，高位在后，结果与0x0000异或

　　CRC16_IBM：多项式x16+x15+x5+1（0x8005），初始值0x0000，低位在前，高位在后，结果与0x0000异或

　　CRC16_MAXIM：多项式x16+x15+x5+1（0x8005），初始值0x0000，低位在前，高位在后，结果与0xFFFF异或

　　CRC16_USB：多项式x16+x15+x5+1（0x8005），初始值0xFFFF，低位在前，高位在后，结果与0xFFFF异或

crc16几种标准校验算法及c语言代码

四、CRC16的算法原理及程序

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

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

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

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

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

　　根据算法原理与标准要求就能简单的写出具体程序：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     /**
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     **************************************************************************************************
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     * @Brief    Single byte data inversion        
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     * @Param    
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     *            @DesBuf: destination buffer
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     *            @SrcBuf: source buffer
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     * @RetVal    None
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     * @Note      (MSB)0101_0101 ---> 1010_1010(LSB)
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     **************************************************************************************************
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     */
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     void InvertUint8(unsigned char *DesBuf, unsigned char *SrcBuf)
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     int i;
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     char temp = 
     
     0;
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     for(i = 
     
     0; i < 
     
     8; i++)
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         {
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     if(SrcBuf[
     
     0] & (
     
     1 << i))
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             {
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 temp |= 
     
     1<<(
     
     7-i);
    
    
    
   
   
  21. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             }
    
    
    
   
   
  22. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }
    
    
    
   
   
  23. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         DesBuf[
     
     0] = temp;
    
    
    
   
   
  24. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  25. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  26. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     /**
    
    
    
   
   
  27. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     **************************************************************************************************
    
    
    
   
   
  28. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     * @Brief    double byte data inversion        
    
    
    
   
   
  29. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     * @Param    
    
    
    
   
   
  30. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     *            @DesBuf: destination buffer
    
    
    
   
   
  31. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     *            @SrcBuf: source buffer
    
    
    
   
   
  32. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     * @RetVal    None
    
    
    
   
   
  33. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     * @Note      (MSB)0101_0101_1010_1010 ---> 0101_0101_1010_1010(LSB)
    
    
    
   
   
  34. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     **************************************************************************************************
    
    
    
   
   
  35. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     */
    
    
    
   
   
  36. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     void InvertUint16(unsigned short *DesBuf, unsigned short *SrcBuf)  
    
    
    
   
   
  37. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {  
    
    
    
   
   
  38. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     int i;  
    
    
    
   
   
  39. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short temp = 
     
     0;    
    
    
    
   
   
  40. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
    
    
    
   
   
  41. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     for(i = 
     
     0; i < 
     
     16; i++)  
    
    
    
   
   
  42. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         {  
    
    
    
   
   
  43. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     if(SrcBuf[
     
     0] & (
     
     1 << i))
    
    
    
   
   
  44. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             {          
    
    
    
   
   
  45. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 temp |= 
     
     1<<(
     
     15 - i);  
    
    
    
   
   
  46. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             }
    
    
    
   
   
  47. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }  
    
    
    
   
   
  48. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         DesBuf[
     
     0] = temp;  
    
    
    
   
   
  49. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  50. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  51. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned short CRC16_CCITT(unsigned char *puchMsg, unsigned int usDataLen)  
    
    
    
   
   
  52. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {  
    
    
    
   
   
  53. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCRCin = 
     
     0x0000;  
    
    
    
   
   
  54. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCPoly = 
     
     0x1021;  
    
    
    
   
   
  55. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     char wChar = 
     
     0;  
    
    
    
   
   
  56. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
    
    
    
   
   
  57. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     while (usDataLen--)     
    
    
    
   
   
  58. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         {  
    
    
    
   
   
  59. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wChar = *(puchMsg++);  
    
    
    
   
   
  60. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             InvertUint8(&wChar, &wChar);  
    
    
    
   
   
  61. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wCRCin ^= (wChar << 
     
     8); 
    
    
    
   
   
  62. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
    
    
    
   
   
  63. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     for(
     
     int i = 
     
     0; i < 
     
     8; i++)  
    
    
    
   
   
  64. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             {  
    
    
    
   
   
  65. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     if(wCRCin & 
     
     0x8000)
    
    
    
   
   
  66. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {
    
    
    
   
   
  67. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = (wCRCin << 
     
     1) ^ wCPoly; 
    
    
    
   
   
  68. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }            
    
    
    
   
   
  69. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     else 
    
    
    
   
   
  70. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {              
    
    
    
   
   
  71. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = wCRCin << 
     
     1;  
    
    
    
   
   
  72. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }
    
    
    
   
   
  73. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             }  
    
    
    
   
   
  74. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }  
    
    
    
   
   
  75. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         InvertUint16(&wCRCin, &wCRCin);  
    
    
    
   
   
  76. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     return (wCRCin) ;  
    
    
    
   
   
  77. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     } 
    
    
    
   
   
  78. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  79. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned short CRC16_CCITT_FALSE(unsigned char *puchMsg, unsigned int usDataLen)  
    
    
    
   
   
  80. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {  
    
    
    
   
   
  81. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCRCin = 
     
     0xFFFF;  
    
    
    
   
   
  82. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCPoly = 
     
     0x1021;  
    
    
    
   
   
  83. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     char wChar = 
     
     0;  
    
    
    
   
   
  84. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
    
    
    
   
   
  85. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     while (usDataLen--)     
    
    
    
   
   
  86. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         {  
    
    
    
   
   
  87. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wChar = *(puchMsg++);  
    
    
    
   
   
  88. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wCRCin ^= (wChar << 
     
     8); 
    
    
    
   
   
  89. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
    
    
    
   
   
  90. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     for(
     
     int i = 
     
     0; i < 
     
     8; i++)  
    
    
    
   
   
  91. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             {  
    
    
    
   
   
  92. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     if(wCRCin & 
     
     0x8000)  
    
    
    
   
   
  93. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {
    
    
    
   
   
  94. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = (wCRCin << 
     
     1) ^ wCPoly;  
    
    
    
   
   
  95. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }
    
    
    
   
   
  96. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     else  
    
    
    
   
   
  97. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {
    
    
    
   
   
  98. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = wCRCin << 
     
     1; 
    
    
    
   
   
  99. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }            
    
    
    
   
   
  100. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             }  
    
    
    
   
   
  101. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }  
    
    
    
   
   
  102. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     return (wCRCin) ;  
    
    
    
   
   
  103. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }  
    
    
    
   
   
  104. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  105. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned short CRC16_XMODEM(unsigned char *puchMsg, unsigned int usDataLen)  
    
    
    
   
   
  106. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {  
    
    
    
   
   
  107. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCRCin = 
     
     0x0000;  
    
    
    
   
   
  108. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCPoly = 
     
     0x1021;  
    
    
    
   
   
  109. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     char wChar = 
     
     0;  
    
    
    
   
   
  110. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
    
    
    
   
   
  111. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     while (usDataLen--)     
    
    
    
   
   
  112. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         {  
    
    
    
   
   
  113. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wChar = *(puchMsg++);  
    
    
    
   
   
  114. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wCRCin ^= (wChar << 
     
     8);
    
    
    
   
   
  115. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
    
    
    
   
   
  116. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     for(
     
     int i = 
     
     0; i < 
     
     8; i++)  
    
    
    
   
   
  117. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             {  
    
    
    
   
   
  118. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     if(wCRCin & 
     
     0x8000)  
    
    
    
   
   
  119. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {
    
    
    
   
   
  120. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = (wCRCin << 
     
     1) ^ wCPoly;  
    
    
    
   
   
  121. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }
    
    
    
   
   
  122. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     else
    
    
    
   
   
  123. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {              
    
    
    
   
   
  124. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = wCRCin << 
     
     1;
    
    
    
   
   
  125. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }
    
    
    
   
   
  126. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             }  
    
    
    
   
   
  127. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }  
    
    
    
   
   
  128. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     return (wCRCin) ;  
    
    
    
   
   
  129. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }  
    
    
    
   
   
  130. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
      
    
    
    
   
   
  131. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned short CRC16_X25(unsigned char *puchMsg, unsigned int usDataLen)  
    
    
    
   
   
  132. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {  
    
    
    
   
   
  133. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCRCin = 
     
     0xFFFF;  
    
    
    
   
   
  134. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCPoly = 
     
     0x1021;  
    
    
    
   
   
  135. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     char wChar = 
     
     0;  
    
    
    
   
   
  136. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
    
    
    
   
   
  137. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     while (usDataLen--)     
    
    
    
   
   
  138. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         {  
    
    
    
   
   
  139. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wChar = *(puchMsg++);  
    
    
    
   
   
  140. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             InvertUint8(&wChar, &wChar);  
    
    
    
   
   
  141. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wCRCin ^= (wChar << 
     
     8); 
    
    
    
   
   
  142. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
    
    
    
   
   
  143. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     for(
     
     int i = 
     
     0;i < 
     
     8;i++)  
    
    
    
   
   
  144. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             {  
    
    
    
   
   
  145. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     if(wCRCin & 
     
     0x8000)
    
    
    
   
   
  146. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {              
    
    
    
   
   
  147. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = (wCRCin << 
     
     1) ^ wCPoly; 
    
    
    
   
   
  148. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }            
    
    
    
   
   
  149. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     else  
    
    
    
   
   
  150. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {
    
    
    
   
   
  151. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = wCRCin << 
     
     1; 
    
    
    
   
   
  152. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }            
    
    
    
   
   
  153. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             }  
    
    
    
   
   
  154. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }  
    
    
    
   
   
  155. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         InvertUint16(&wCRCin, &wCRCin);  
    
    
    
   
   
  156. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     return (wCRCin^
     
     0xFFFF) ;  
    
    
    
   
   
  157. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }  
    
    
    
   
   
  158. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
      
    
    
    
   
   
  159. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned short CRC16_MODBUS(unsigned char *puchMsg, unsigned int usDataLen)  
    
    
    
   
   
  160. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {  
    
    
    
   
   
  161. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCRCin = 
     
     0xFFFF;  
    
    
    
   
   
  162. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCPoly = 
     
     0x8005;  
    
    
    
   
   
  163. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     char wChar = 
     
     0;  
    
    
    
   
   
  164. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
    
    
    
   
   
  165. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     while (usDataLen--)     
    
    
    
   
   
  166. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         {  
    
    
    
   
   
  167. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wChar = *(puchMsg++);  
    
    
    
   
   
  168. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             InvertUint8(&wChar, &wChar);  
    
    
    
   
   
  169. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wCRCin ^= (wChar << 
     
     8); 
    
    
    
   
   
  170. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
    
    
    
   
   
  171. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     for(
     
     int i = 
     
     0; i < 
     
     8; i++)  
    
    
    
   
   
  172. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             {  
    
    
    
   
   
  173. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     if(wCRCin & 
     
     0x8000) 
    
    
    
   
   
  174. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {
    
    
    
   
   
  175. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = (wCRCin << 
     
     1) ^ wCPoly;  
    
    
    
   
   
  176. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }
    
    
    
   
   
  177. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     else  
    
    
    
   
   
  178. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {
    
    
    
   
   
  179. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = wCRCin << 
     
     1; 
    
    
    
   
   
  180. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }            
    
    
    
   
   
  181. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             }  
    
    
    
   
   
  182. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }  
    
    
    
   
   
  183. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         InvertUint16(&wCRCin, &wCRCin);  
    
    
    
   
   
  184. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     return (wCRCin) ;  
    
    
    
   
   
  185. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     } 
    
    
    
   
   
  186. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  187. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned short CRC16_IBM(unsigned char *puchMsg, unsigned int usDataLen)  
    
    
    
   
   
  188. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {  
    
    
    
   
   
  189. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCRCin = 
     
     0x0000;  
    
    
    
   
   
  190. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCPoly = 
     
     0x8005;  
    
    
    
   
   
  191. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     char wChar = 
     
     0;  
    
    
    
   
   
  192. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
    
    
    
   
   
  193. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     while (usDataLen--)     
    
    
    
   
   
  194. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         {  
    
    
    
   
   
  195. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wChar = *(puchMsg++);  
    
    
    
   
   
  196. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             InvertUint8(&wChar, &wChar);  
    
    
    
   
   
  197. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wCRCin ^= (wChar << 
     
     8);  
    
    
    
   
   
  198. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
    
    
    
   
   
  199. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     for(
     
     int i = 
     
     0; i < 
     
     8; i++)  
    
    
    
   
   
  200. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             {  
    
    
    
   
   
  201. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     if(wCRCin & 
     
     0x8000)  
    
    
    
   
   
  202. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {
    
    
    
   
   
  203. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = (wCRCin << 
     
     1) ^ wCPoly; 
    
    
    
   
   
  204. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }            
    
    
    
   
   
  205. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     else  
    
    
    
   
   
  206. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {
    
    
    
   
   
  207. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = wCRCin << 
     
     1;  
    
    
    
   
   
  208. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }
    
    
    
   
   
  209. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             }  
    
    
    
   
   
  210. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }  
    
    
    
   
   
  211. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         InvertUint16(&wCRCin,&wCRCin);  
    
    
    
   
   
  212. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     return (wCRCin) ;  
    
    
    
   
   
  213. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }  
    
    
    
   
   
  214. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  215. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned short CRC16_MAXIM(unsigned char *puchMsg, unsigned int usDataLen)  
    
    
    
   
   
  216. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {  
    
    
    
   
   
  217. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCRCin = 
     
     0x0000;  
    
    
    
   
   
  218. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCPoly = 
     
     0x8005;  
    
    
    
   
   
  219. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     char wChar = 
     
     0;  
    
    
    
   
   
  220. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
    
    
    
   
   
  221. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     while (usDataLen--)     
    
    
    
   
   
  222. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         {  
    
    
    
   
   
  223. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wChar = *(puchMsg++);  
    
    
    
   
   
  224. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             InvertUint8(&wChar, &wChar);  
    
    
    
   
   
  225. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wCRCin ^= (wChar << 
     
     8);  
    
    
    
   
   
  226. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
    
    
    
   
   
  227. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     for(
     
     int i = 
     
     0; i < 
     
     8; i++)  
    
    
    
   
   
  228. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             {  
    
    
    
   
   
  229. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     if(wCRCin & 
     
     0x8000) 
    
    
    
   
   
  230. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {              
    
    
    
   
   
  231. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = (wCRCin << 
     
     1) ^ wCPoly;
    
    
    
   
   
  232. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }
    
    
    
   
   
  233. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     else 
    
    
    
   
   
  234. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {              
    
    
    
   
   
  235. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = wCRCin << 
     
     1;  
    
    
    
   
   
  236. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }
    
    
    
   
   
  237. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             }  
    
    
    
   
   
  238. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }  
    
    
    
   
   
  239. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         InvertUint16(&wCRCin, &wCRCin);  
    
    
    
   
   
  240. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     return (wCRCin^
     
     0xFFFF) ;  
    
    
    
   
   
  241. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }  
    
    
    
   
   
  242. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  243. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     unsigned short CRC16_USB(unsigned char *puchMsg, unsigned int usDataLen)  
    
    
    
   
   
  244. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {  
    
    
    
   
   
  245. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCRCin = 
     
     0xFFFF;  
    
    
    
   
   
  246. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     short wCPoly = 
     
     0x8005;  
    
    
    
   
   
  247. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     unsigned 
     
     char wChar = 
     
     0;  
    
    
    
   
   
  248. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
    
    
    
   
   
  249. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     while (usDataLen--)     
    
    
    
   
   
  250. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         {  
    
    
    
   
   
  251. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wChar = *(puchMsg++);  
    
    
    
   
   
  252. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             InvertUint8(&wChar, &wChar);  
    
    
    
   
   
  253. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             wCRCin ^= (wChar << 
     
     8); 
    
    
    
   
   
  254. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
    
    
    
   
   
  255. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     for(
     
     int i = 
     
     0; i < 
     
     8; i++)  
    
    
    
   
   
  256. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             {  
    
    
    
   
   
  257. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     if(wCRCin & 
     
     0x8000) 
    
    
    
   
   
  258. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {              
    
    
    
   
   
  259. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = (wCRCin << 
     
     1) ^ wCPoly;
    
    
    
   
   
  260. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }            
    
    
    
   
   
  261. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
                
     
     else  
    
    
    
   
   
  262. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 {
    
    
    
   
   
  263. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                     wCRCin = wCRCin << 
     
     1; 
    
    
    
   
   
  264. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
                 }            
    
    
    
   
   
  265. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
             }  
    
    
    
   
   
  266. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }  
    
    
    
   
   
  267. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         InvertUint16(&wCRCin, &wCRCin);  
    
    
    
   
   
  268. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
        
     
     return (wCRCin^
     
     0xFFFF) ;  
    
    
    
   
   
  269. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }

 

Jin_Cheng@csdn
关注
  • 2
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CRC-16校验码生成
04-18
CRC校验码生成小程序，大大减小了编程的难度
CRC16校验工具---x16+x12+x5+1
08-06
16位CRC校验码工具，适用于0x11021,生成多项式为x16+x12+x5+1
PHP实现CRC16-CCITT算法（附完整源码）
最新发布
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-30 104
PHP实现CRC16-CCITT算法（附完整源码）
三种CRC16 C语言算法理解（CCITT）
热门推荐
j824117879的博客
08-24 3万+
三种CRC16的算法实现，结合自己的理解记录一下； 一、先说算法的C语言实现和各算法的优缺点： 1、按位计算CRC 代码如下 uint16_t crc_16(uint8_t *data, uint16_t len) {     uint16_t crc16 = 0x0000;          while( len-- ) {         for(uint8_t i=0x80; i!=...
CRC16常见几个标准的算法及C语言实现
yundanfengqing_nuc的专栏
10-29 2413
CRC16常见的标准有以下几种，被用在各个规范中，其算法原理基本一致，就是在数据的输入和输出有所差异，下边把这些标准的差异列出，并给出C语言的算法实现。 CRC16_CCITT：多项式x16+x12+x5+1（0x1021），初始值0x0000，低位在前，高位在后，结果与0x0000异或 CRC16_CCITT_FALSE：多项式x16+x12+x5+1（0x1021），初始值0xFFFF，低位在后，高位在前，结果与0x0000异或 CRC16_XMODEM：多项式x16+x12+x5+1（0x102
C语言CRC-16 CCITT格式校验函数
Pegasus的软件博客
05-15 2998
CRC-16校验产生2个字节长度的数据校验码，通过计算得到的校验码和获得的校验码比较，用于验证获得的数据的正确性。不同同应用规范通过对输入数据前处理和输出数据后处理的方式不同，又产生了不同的应用规范校验函数，这里介绍CCITT格式的CRC-16校验函数。生成多项式为x^16 + x^12 + x^5 + 1。
crc16 ccitt的详细标准及其出处
weixin_35751194的博客
02-16 2880
CRC16-CCITT是一个16位的循环冗余校验(CRC)算法，它是由国际电报电话咨询委员会(CCITT)制定的。该算法被广泛用于通信领域，以验证数据传输的完整性。 以下是CRC16-CCITT算法的详细标准： 多项式生成器(Polynomial Generator)： x^16 + x^12 + x^5 + 1 初始值(Initial Value)：0xFFFF 处理顺序(Processing...
CRC8/CRC16/CRC32常见几个标准的算法及C语言实现
03-15
在给定的压缩包中，`crc.c`和`crc.h`文件很可能是包含CRC算法实现的源代码。`readme.url`可能是一个指向相关文档或教程的链接。在实际使用这些代码时，首先需要包含`crc.h`头文件，然后调用相应的函数，如`crc8()`, ...
crc16几种标准校验算法及c语言代码.docx
07-14
"crc16几种标准校验算法及c语言代码" crc16是一种常用的循环冗余校验算法，用于检测数据传输中的错误。该算法的实现包括选择初始值、异或操作、移位操作和最终结果的计算。crc16的标准有多种，包括crc16-ccitt、crc...
CRC算法原理及C语言实现.pdf
06-04
CRC算法原理及C语言实现：CRC计算与普通的除法计算有所不同。普通的除法计算是借位相减的，而CRC计算则是异或运算。任何一个除法运算都需要选取一个除数，在CRC运算中我们称之为poly，而宽度W就是poly最高位的位置。...
商业编程-源码-CRC算法及C语言实现.zip
06-20
在C语言中实现CRC算法，需要理解以下几个关键概念： 1. **生成多项式**：这是CRC的核心，决定了校验位的数量和CRC码的特性。例如，常见的CRC-16使用生成多项式G(x) = x^16 + x^15 + x^2 + 1，这将产生16位的CRC码。...
C语言实现CRC16算法，生成单字节校验值
11-08
使用C语言实现了CRC16算法，并生成了单字节校验值
CRC-16 CCITT
林愿留的博客
07-24 9610
CRC（循环冗余校验）在线计算 /*CRC-16 CCITT*/ // CCITT: x^16 + x^12 + x^5 + x^0 (0x1021) /*高位在左低位在右，使用时请注意高低位顺序！！！*/ unsigned short CRC16_CCITT (unsigned char *pdata, int len){ unsigned short crc=0x0000;//初始值 int i, j; for ( j=0; j<len;j++) { crc^=pdata[j];
crc标准算法
FSCore的专栏
05-02 494
#include <stdlib.h> #include <stdio.h> #include "crc.h" #if 0 unsigned int GetTickCount(void) { struct timeval tv; if (gettimeofday(&tv, NULL)!=0) return 0; return...
CRC-16/MODBUS 与 CRC-16/CCITT-FALSE 校验位 计算
aming090的博客
09-28 7653
CRC-16/MODBUS  与  CRC-16/CCITT-FALSE 校验位 计算 #include "stdafx.h" #include &lt;windows.h&gt; ////////////////////////////////////////////////////////// CRC-16/MODBUS 第一种方式////////////////////////////...
国际标准协议之CRC
记录人生
04-10 1万+
CRC CRC为校验和的一种，是两个字节数据流采用二进制除法（没有进位，使用XOR来代替减法）相除所得到的余数。其中被除数是需要计算校验和的信息数据流的二进制表示；除数是一个长度为的预定义（短）的二进制数，通常用多项式的系数来表示。在做除法之前，要在信息数据之后先加上个0. 常用CRC（按照ITU-IEEE规范） 名称 多项式 表示法：正常或者翻转
CRC16-CITT算法
baidu_31620299的博客
04-15 2375
1、CRC16-CITT C-code example 1 (fast) This example uses a look-up table with pre-calculated CRCs for fast calculation./* function declarations */ unsigned int CalcCRC(unsigned int size,unsigned char *...
CRC16浅析
Nuko的博客
09-07 1万+
CRC即循环冗余校验码（Cyclic Redundancy Check），是数据通信领域中最常用的一种查错校验码。奇偶校验虽然简单，但是漏检率太高，而CRC则要低的多，所以大多数都是使用CRC来校验。CRC也称为多项式码。 任何一个由二进制数位串组成的代码，都可以唯一的与一个只含有0和1两个系数的多项式建立一一对应的关系。如：1010111对应的多项式为X^6 + X^4 + X^2 + X +...
C#crc16校验和
small5e4444的专栏
06-10 5604
从网上搜了好久都没搞定，我老大一搜就好使，什么人品！ 我的资源里有：http://download.csdn.net/detail/small5e4444/3724860   一下程序写在button事件里就行                     byte[] data = new byte[6];                 string[] st = textBo
CRC校验算法的讲解以及算法实现（C语言）
11-19
CRC校验算法的讲解以及算法实现（C语言），包括CRC8，CRC16，CRC32，另外通过宏定义修改可实现所有算法的通用，可移植性和通用性高。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值