Coursify

CRC Sender-Side and Receiver-Side Steps (with Worked Examples)

CRC Sender-Side and Receiver-Side Steps (with Worked Examples)

Verified Sources
Sep 12, 2026

Cyclic Redundancy Check (CRC ) appends a short checksum (the CRC remainder) to the message. The sender computes the remainder using generator polynomial and modulo-2 division. The receiver recomputes and checks whether the remainder indicates an error. The core theory is: treat message bits as a polynomial over GF(2) and divide by G(x)G(x) to get a remainder. For a properly constructed codeword, the receiver’s final remainder is 00.2

Key idea (common “append zeros then divide” variant):

  • Sender forms W(x)=M(x) xn+R(x)W(x)=M(x)\,x^n + R(x) such that W(x)W(x) is divisible by G(x)G(x); then it transmits the last nn bits as the CRC remainder R(x)R(x).
  • Receiver divides the received codeword W′(x)W'(x) by G(x)G(x) and checks that the remainder is 00 (if not, an error is detected).2

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩ ↩2

  2. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩ ↩2

  3. Cyclic redundancy check - Notes that typical verification can be done by computing the remainder on the received bitstream and checking it equals zero. ↩

CRC sender/receiver intuition (walkthrough)

Essential terminology for the steps

We’ll use a standard CRC setup:

  • Let G(x)G(x) be the generator polynomial with degree nn (so the CRC remainder has nn bits).2
  • Let MM be the data bits to protect; interpret them as M(x)M(x).
  • Use modulo-2 arithmetic: subtract = XOR in the division process.

Useful keywords introduced here:

  • generator polynomial
  • remainder
  • codeword

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩ ↩2

  2. Cyclic redundancy check and modulo-2 division (GeeksforGeeks) - Explains generator polynomial/key representation and the role of nn (degree/remainder bit length). ↩

  3. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

Sender and Receiver CRC workflow

Sender: prepare dividend

1

Append nn zeros to message to create M(x)xnM(x)x^n"

Sender: compute CRC

2

Modulo-2 divide by G(x)G(x) to get remainder R(x)R(x)"

Sender: transmit codeword

3

Send W=M∣∣RW = M || R (message followed by CRC bits)"

Receiver: recompute remainder

4

Divide received bits by G(x)G(x)"

Receiver: decide

5

If remainder is 00, accept; else detect an error"

Sender-side steps to compute and append CRC

  1. 1
    Step 1

    Both sides must agree on G(x)G(x) (the CRC key). The remainder length equals degree nn of G(x)G(x). 2

    Footnotes

    1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

    2. Cyclic redundancy check and modulo-2 division (GeeksforGeeks) - Explains generator polynomial/key representation and the role of nn (degree/remainder bit length). ↩

  2. 2
    Step 2

    Let nn be degree of G(x)G(x). Append nn zeros to the message bitstring to form the dividend M(x)xnM(x)x^n. 2

    Footnotes

    1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

    2. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

  3. 3
    Step 3

    Divide the dividend by G(x)G(x) using modulo-2 (XOR) polynomial division. The degree of G(x)G(x) ensures the remainder has at most nn bits; take the remainder R(x)R(x). 2

    Footnotes

    1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

    2. Cyclic redundancy check - Notes that typical verification can be done by computing the remainder on the received bitstream and checking it equals zero. ↩

  4. 4
    Step 4

    Append the remainder bits to the original message: W(x)=M(x)xn+R(x)W(x)=M(x)x^n+R(x). Transmit WW as the codeword.

    Footnotes

    1. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

  5. 5
    Step 5

    If you use a key bitstring for G(x)G(x) (e.g., 1101 represents x3+x2+1x^3+x^2+1), keep bit ordering consistent during division. 2

    Footnotes

    1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

    2. Cyclic redundancy check and modulo-2 division (GeeksforGeeks) - Explains generator polynomial/key representation and the role of nn (degree/remainder bit length). ↩

Receiver-side steps to verify CRC

  1. 1
    Step 1

    Let the receiver obtain W′W' (the transmitted codeword possibly corrupted by channel errors).

    Footnotes

    1. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

  2. 2
    Step 2

    Perform the same modulo-2 division of W′W' by G(x)G(x).

    Footnotes

    1. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

  3. 3
    Step 3

    If the remainder is 00, treat the codeword as valid (no detectable error by this CRC). Otherwise, detect an error. 2

    Footnotes

    1. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

    2. Cyclic redundancy check - Notes that typical verification can be done by computing the remainder on the received bitstream and checking it equals zero. ↩

  4. 4
    Step 4

    When remainder is 00, the receiver can discard the last nn CRC bits and use the earlier MM bits as the recovered message.

    Footnotes

    1. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

Worked Example 1: Sender + receiver using G(x)=1101G(x)=1101 (degree 33), Data = 100100100100

We’ll use the common textbook CRC example where G(x)=1101G(x)=1101 (so n=3n=3) and M=100100M=100100.

  • Degree n=3n=3 ⇒ append 33 zeros to the message to form 100100000100100000.
  • Compute remainder using modulo-2 division to get R=001R=001.
  • Transmitted codeword becomes W=M∣∣R=100100001W = M || R = 100100001.

Sender-side (explicit steps)

  1. Message: M=100100M=100100
  2. Append n=3n=3 zeros: M xn⇒100100000M\,x^n \Rightarrow 100100000
  3. Modulo-2 divide 100100000100100000 by G=1101G=1101 → remainder R=001R=001.
  4. Transmit W=100100001W=100100001.

Receiver-side (explicit steps)

  1. Receiver gets W′W'
    • (No error case) W′=100100001W'=100100001
  2. Divide W′W' by G=1101G=1101
  3. Remainder is 00 → no detectable error.

Error case illustration (single-bit flip concept)

If the channel flips one bit, the receiver may get something like W′=100000001W'=100000001; dividing by GG yields a non-zero remainder, so the receiver detects an error.

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

  2. Cyclic Redundancy Check | CRC | Example - Provides the worked example with Data = 100100 and Key 1101, remainder 001, transmitted codeword 100100001, and receiver remainder check (0 for no error). ↩ ↩2 ↩3 ↩4 ↩5 ↩6

Worked Example 2: “Check by re-dividing the received full codeword”

A convenient CRC implementation variant is explicitly described in CRC theory and common practice:

  • If you build the transmitted codeword by appending the correct CRC remainder, then the receiver’s remainder check on the full received codeword should be 00.2
  • This avoids needing to “extract CRC and compare two CRC values” in many hardware implementations. Instead, it just performs the division and checks for zero remainder.

This matches the receiver logic: “divide the received bitstring by G(x)G(x) and check remainder is zero; if so, assume the received message bits are correct.”

Footnotes

  1. Cyclic redundancy check - Notes that typical verification can be done by computing the remainder on the received bitstream and checking it equals zero. ↩ ↩2

  2. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

  3. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

type="tip" title="Pro Tip: Use the “remainder-zeros” property" content="If your sender computes CRC by appending the remainder to the message after dividing (with standard construction), then the receiver can verify by dividing the entire received codeword and checking that the remainder is 00. This is explicitly described as the typical CRC checking approach."2"

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

  2. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

type="warning" title="Warning: Division must be modulo-2 (XOR) not integer arithmetic" content="CRC polynomial division operates in GF(2). In modulo-2 division, subtraction equals XOR (no borrows/carries like decimal subtraction). If you use normal integer division/subtraction, you’ll get a wrong remainder and mismatched sender/receiver results."2"

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

  2. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩

Mini summary table (steps side-by-side)

StageInputOperationOutput / DecisionKey CRC fact
SenderMM and GGAppend zeros; modulo-2 divideCRC remainder RRRemainder has nn bits where n=deg⁡(G)n=\deg(G)2
SenderMM and RRConcatenateTransmitted codeword WWWW is divisible by GG (construction)
ReceiverW′W' and GGDivide W′W' by GGremainder 00 or non-zeroIf remainder is 00, accept; else detect error2

Footnotes

  1. Cyclic redundancy check - Describes CRC as remainder of polynomial division over GF(2), and typical append-zero/check approach. ↩

  2. Cyclic redundancy check and modulo-2 division (GeeksforGeeks) - Explains generator polynomial/key representation and the role of nn (degree/remainder bit length). ↩

  3. Mathematics of cyclic redundancy checks - States the sender’s division form and receiver’s “divide W' by G(x) and check remainder is zero” rule. ↩ ↩2

  4. Cyclic redundancy check - Notes that typical verification can be done by computing the remainder on the received bitstream and checking it equals zero. ↩

Common questions about sender/receiver CRC steps

Knowledge Check

Question 1 of 4
Q1Single choice

In the standard CRC construction, if the generator polynomial degree is nn, the sender appends how many zeros to the message before division?

Explore Related Topics

1

Count-to-Infinity in Distance-Vector Routing & Countermeasures (Split Horizon, Poison Reverse)

2

Various Addressing Modes of 8051 Microcontroller

The 8051 microcontroller provides multiple addressing modes that define how an instruction identifies the location or value of its operand.

  • Immediate (#data) – constant value encoded in the instruction, used for loading fixed numbers.
  • Register (Rn) – operand resides in CPU registers R0‑R7 (or A/B), giving the shortest and fastest code.
  • Direct (addr) – 8‑bit address is part of the opcode, accessing internal RAM or SFRs directly.
  • Register indirect (@R0, @R1, @DPTR) – a register holds the operand’s address, enabling pointer‑like traversal of memory.
  • Indexed (@A+DPTR or @A+PC) – adds the accumulator to DPTR or PC for table look‑ups in code memory; branch modes (relative, absolute, long) extend this concept for short, page‑limited, and full‑range jumps.
3

Data Communication Components: Various Connection Topology, Protocols and Standards

Data communication fundamentals are presented, detailing the five essential components, common physical and logical topologies, protocol layering (OSI and TCP/IP), and the standards bodies that ensure interoperability.

  • Core components: message, sender, receiver, transmission medium, protocol; transmission modes include simplex, half‑duplex, and full‑duplex.
  • Topologies: bus, star, ring, mesh, tree, hybrid—each balancing cost, fault tolerance, scalability, and complexity.
  • Protocols define syntax, semantics, and timing; OSI (7 layers) and TCP/IP (4 layers) use key protocols such as IP, TCP, UDP, HTTP.
  • Standards from ISO, ITU‑T, IEEE (e.g., 802.3 Ethernet, 802.11 Wi‑Fi) and IETF guarantee vendor‑independent communication.
  • Design guidance: align requirements with appropriate topology, media, protocol stack, and verify compliance with relevant standards.
Browse all research articles