Crc-16 Algorithm - GE Multilin 745 Communications Manual

CHAPTER 2: MODBUS PROTOCOL

CRC-16 algorithm

745 TRANSFORMER PROTECTION SYSTEM – COMMUNICATIONS GUIDE
• CRC: This is a two byte error checking code. The RTU version of Modbus includes a
two-byte CRC-16 (16-bit cyclic redundancy check) with every message. The CRC-16
algorithm essentially treats the entire data stream (data bits only; start, stop and
parity ignored) as one continuous binary number. This number is first shifted left 16
bits and then divided by a characteristic polynomial (11000000000000101B). The 16
bit remainder of the division is appended to the end of the message, MSByte first. The
resulting message including CRC, when divided by the same polynomial at the
receiver will give a zero remainder if no transmission errors have occurred. If a GE
Multilin Modbus slave device receives a message in which an error is indicated by the
CRC-16 calculation, the slave device will not respond to the message. A CRC-16 error
indicates that one or more bytes of the message were received incorrectly and thus
the entire message should be ignored in order to avoid the slave device performing
any incorrect operation. The CRC-16 calculation is an industry standard method used
for error detection.
Once the following algorithm is completed, the working register "A" will contain the CRC
value to be transmitted. Note that this algorithm requires the characteristic polynomial to
be reverse bit ordered. The most significant bit of the characteristic polynomial is dropped,
since it does not affect the value of the remainder. The following symbols are used in the
algorithm:
• : data transfer
—>
• : 16 bit working register
A
• : low order byte of A
AL
• : high order byte of A
AH
• : 16-bit CRC-16 value
CRC
• , : loop counters
i j
• : logical exclusive or operator
(+)
• : i-th data byte (i = 0 to N-1)
Di
• : 16 bit characteristic polynomial = 1010000000000001 with the most significant bit
G
dropped and bit order reversed
• : shift right (the least significant bit of the low order byte of x shifts into a carry
shr(x)
flag, a '0' is shifted into the most significant bit of the high order byte of x, all other bits
shift right one location
The algorithm is:
1. FFFF hex —> A
2. 0 —> i
3. 0 —> j
4. Di (+) AL —> AL
5. j + 1 —> j
6. shr(A)
7. is there a carry? If No, go to 8; If Yes, G (+) A —> A
8. is j = 8? If No, go to 5; If Yes, go to 9.
9. i + 1 —> i
10. is i = N? If No, go to 3; If Yes, go to 11.
11. A —> CRC
MODBUS PROTOCOL
2–3