开发和技术
6 分钟 读完 (大约 881 个字)

CRC16 原理及 Java 实现

校验方式详解

校验方式 多项式 初始值 前/后 异或值
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） 0xFFFF 低/高 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_DNP x16+x13+x12+x11+x10+
x8+x6+x5+x2+1（0x3D65）		 0x0000 低/高 0xFFFF

校验原理和步骤

  1. 预置1个16位的寄存器为十六进制FFFF（即全为1），称此寄存器为CRC寄存器；
  2. 把第一个8位二进制数据（既通讯信息帧的第一个字节）与16位的CRC寄存器的低8位相异或，把结果放于CRC寄存器，高八位数据不变；
  3. 把CRC寄存器的内容右移一位（朝低位）用0填补最高位，并检查右移后的移出位；
  4. 如果移出位为0：重复第3步（再次右移一位）；如果移出位为1，CRC寄存器与多项式A001（1010 0000 0000 0001）进行异或；
  5. 重复步骤3和4，直到右移8次，这样整个8位数据全部进行了处理；
  6. 重复步骤2到步骤5，进行通讯信息帧下一个字节的处理；
  7. 将该通讯信息帧所有字节按上述步骤计算完成后，得到的16位CRC寄存器的高、低字节进行交换；
  8. 最后得到的CRC寄存器内容即为：CRC码。
  • 以上计算步骤中的多项式 0xA001 是 0x8005 按位颠倒后的结果。
  • 0x8408 是 0x1021 按位颠倒后的结果。

Java 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
/**
 * Author:boxla
 * Time:2019/09/11 16:09
 */
public class CRC16 {
 
    /**
     * @param buffer
     * @return
     */
    public static int CRC16_CCITT(byte[] buffer) {
        int wCRCin = 0x0000;
        int wCPoly = 0x8408;
        for (byte b : buffer) {
            wCRCin ^= ((int) b & 0x00ff);
            for (int j = 0; j < 8; j++) {
                if ((wCRCin & 0x0001) != 0) {
                    wCRCin >>= 1;
                    wCRCin ^= wCPoly;
                } else {
                    wCRCin >>= 1;
                }
            }
        }
        return wCRCin ^= 0x0000;
 
    }
 
    /**
     * @param buffer
     * @return
     */
    public static int CRC16_CCITT_FALSE(byte[] buffer) {
        int wCRCin = 0xffff;
        int wCPoly = 0x1021;
        for (byte b : buffer) {
            for (int i = 0; i < 8; i++) {
                boolean bit = ((b >> (7 - i) & 1) == 1);
                boolean c15 = ((wCRCin >> 15 & 1) == 1);
                wCRCin <<= 1;
                if (c15 ^ bit)
                    wCRCin ^= wCPoly;
            }
        }
        wCRCin &= 0xffff;
        return wCRCin ^= 0x0000;
    }
 
    /**
     * @param buffer
     * @return
     */
    public static int CRC16_XMODEM(byte[] buffer) {
        int wCRCin = 0x0000;
        int wCPoly = 0x1021;
        for (byte b : buffer) {
            for (int i = 0; i < 8; i++) {
                boolean bit = ((b >> (7 - i) & 1) == 1);
                boolean c15 = ((wCRCin >> 15 & 1) == 1);
                wCRCin <<= 1;
                if (c15 ^ bit)
                    wCRCin ^= wCPoly;
            }
        }
        wCRCin &= 0xffff;
        return wCRCin ^= 0x0000;
    }
 
 
    /**
     * @param buffer
     * @return
     */
    public static int CRC16_X25(byte[] buffer) {
        int wCRCin = 0xffff;
        int wCPoly = 0x8408;
        for (byte b : buffer) {
            wCRCin ^= ((int) b & 0x00ff);
            for (int j = 0; j < 8; j++) {
                if ((wCRCin & 0x0001) != 0) {
                    wCRCin >>= 1;
                    wCRCin ^= wCPoly;
                } else {
                    wCRCin >>= 1;
                }
            }
        }
        return wCRCin ^= 0xffff;
    }
 
    /**
     * @param buffer
     * @return
     */
    public static int CRC16_MODBUS(byte[] buffer) {
        int wCRCin = 0xffff;
        int POLYNOMIAL = 0xa001;
        for (byte b : buffer) {
            wCRCin ^= ((int) b & 0x00ff);
            for (int j = 0; j < 8; j++) {
                if ((wCRCin & 0x0001) != 0) {
                    wCRCin >>= 1;
                    wCRCin ^= POLYNOMIAL;
                } else {
                    wCRCin >>= 1;
                }
            }
        }
        return wCRCin ^= 0x0000;
    }
 
    /**
     * @param buffer
     * @return
     */
    public static int CRC16_IBM(byte[] buffer) {
        int wCRCin = 0x0000;
        int wCPoly = 0xa001;
        for (byte b : buffer) {
            wCRCin ^= ((int) b & 0x00ff);
            for (int j = 0; j < 8; j++) {
                if ((wCRCin & 0x0001) != 0) {
                    wCRCin >>= 1;
                    wCRCin ^= wCPoly;
                } else {
                    wCRCin >>= 1;
                }
            }
        }
        return wCRCin ^= 0x0000;
    }
 
    /**
     * @param buffer
     * @return
     */
    public static int CRC16_MAXIM(byte[] buffer) {
        int wCRCin = 0x0000;
        int wCPoly = 0xa001;
        for (byte b : buffer) {
            wCRCin ^= ((int) b & 0x00ff);
            for (int j = 0; j < 8; j++) {
                if ((wCRCin & 0x0001) != 0) {
                    wCRCin >>= 1;
                    wCRCin ^= wCPoly;
                } else {
                    wCRCin >>= 1;
                }
            }
        }
        return wCRCin ^= 0xffff;
    }
 
    /**
     * @param buffer
     * @return
     */
    public static int CRC16_USB(byte[] buffer) {
        int wCRCin = 0xFFFF;
        int wCPoly = 0xa001;
        for (byte b : buffer) {
            wCRCin ^= ((int) b & 0x00ff);
            for (int j = 0; j < 8; j++) {
                if ((wCRCin & 0x0001) != 0) {
                    wCRCin >>= 1;
                    wCRCin ^= wCPoly;
                } else {
                    wCRCin >>= 1;
                }
            }
        }
        return wCRCin ^= 0xffff;
    }
 
    /**
     * @param buffer
     * @return
     */
    public static int CRC16_DNP(byte[] buffer) {
        int wCRCin = 0x0000;
        int wCPoly = 0xA6BC;
        for (byte b : buffer) {
            wCRCin ^= ((int) b & 0x00ff);
            for (int j = 0; j < 8; j++) {
                if ((wCRCin & 0x0001) != 0) {
                    wCRCin >>= 1;
                    wCRCin ^= wCPoly;
                } else {
                    wCRCin >>= 1;
                }
            }
        }
        return wCRCin ^= 0xffff;
    }
}

相关资料

在线 CRC 校验工具

CRC16计算公式、初始值、标志位等参数汇总

# Java

请博主喝瓶可乐吧

人为操作使系统崩溃方法汇总
Centos7 安装 Nodejs 最新版本

评论

Follow on Github

分类

友链

最新文章

归档

标签

Android 19
CentOS 1
DDLC 1
ESP8266 1
Java 4
JavaScript 1
Lua 1
NodeMCU 1
PanDownload 1
Python 2
Ubuntu 1
Unity3D 1
macOS 1
mojave 1
作品 2
故障 1
白嫖 1
网络安全 2

最新文章

归档

标签

Android 19
CentOS 1
DDLC 1
ESP8266 1
Java 4
JavaScript 1
Lua 1
NodeMCU 1
PanDownload 1
Python 2
Ubuntu 1
Unity3D 1
macOS 1
mojave 1
作品 2
故障 1
白嫖 1
网络安全 2
Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×