devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：小小林熬夜学编程 | 2024-02-19 05:51:19

赞

踩

crc16ccitt

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

  
  
  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. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
     
     
     
    
    
    

  
  
  • 1

具体验证使用这个工具，内含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. 
    
    
    
     
     
    
    
    
    
    
    
    
     
     
    
      
      
     
     
    
    
    

  
  
  • 1
对于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. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   

 
 
  • 1

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/112994
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号