Data transmission: methods of error detection (parity bits, majority voting, checksums, echo checking)

What you'll learn

When data travels across networks or between computer components, transmission errors can occur due to electrical interference, signal degradation, or hardware faults. This revision guide explains the four key error detection methods you need to know for CIE IGCSE Computer Science: parity bits, checksums, echo checking, and majority voting. You'll learn how each method works, their advantages and limitations, and how to apply them in exam questions.

Key terms and definitions

Parity bit — An extra bit added to a binary string to make the total number of 1s either even (even parity) or odd (odd parity), used to detect single-bit transmission errors.

Checksum — A calculated value derived from a block of data that is transmitted alongside the data; the receiver recalculates the checksum to verify data integrity.

Echo checking — A method where the receiver sends received data back to the sender, who compares it with the original to detect errors.

Majority voting — A technique where the same data is transmitted multiple times (typically three), and the most frequently received value is accepted as correct.

Transmission error — Corruption of data that occurs during transfer from sender to receiver, where bits may be changed, lost, or added.

Even parity — A parity system where the total number of 1 bits in a binary string (including the parity bit) must be even.

Odd parity — A parity system where the total number of 1 bits in a binary string (including the parity bit) must be odd.

Automatic Repeat Request (ARQ) — A protocol where the receiver requests retransmission of data when an error is detected.

Core concepts

Understanding transmission errors

Data transmission errors occur when binary data changes during transfer between devices. These errors happen for several reasons:

• Electrical interference from nearby devices or cables
• Signal attenuation (weakening) over long distances
• Physical damage to transmission media
• Electromagnetic interference from weather conditions
• Hardware malfunctions in network equipment

A single-bit error changes one bit from 0 to 1 or vice versa. For example, 10110101 might become 10111101 (the fifth bit flipped). Burst errors affect multiple consecutive bits. Error detection methods identify when errors have occurred, though they don't automatically correct them.

When an error is detected, the receiving device typically requests retransmission of the corrupted data. This ensures data integrity but increases transmission time and network traffic.

Parity bits (even and odd parity)

The parity bit is the simplest and most common error detection method. A single bit is added to each byte or data unit before transmission.

Even parity adds a bit so the total number of 1s becomes even:

• Original data: 1011010 (contains four 1s — already even)
• Parity bit added: 0
• Transmitted data: 10110100

Odd parity adds a bit so the total number of 1s becomes odd:

• Original data: 1011010 (contains four 1s — currently even)
• Parity bit added: 1
• Transmitted data: 10110101

The receiver counts the 1s in the received data. If even parity is used and the count is odd, an error has occurred. The receiver then requests retransmission.

Advantages of parity checking:

• Simple to implement and requires minimal additional data
• Fast to calculate and check
• Low computational overhead
• Widely supported in hardware

Limitations of parity checking:

• Only detects single-bit errors reliably
• Cannot detect errors affecting an even number of bits (e.g., if two bits flip, parity remains correct)
• Cannot identify which bit is wrong
• Cannot correct errors, only detect them

Checksums

A checksum is a calculated value based on the data being transmitted. The sender performs a calculation on the data block and transmits the checksum alongside the data. The receiver performs the same calculation and compares results.

Common checksum method:

1. Divide the data into equal-sized blocks (e.g., 8-bit bytes)
2. Add all blocks together numerically
3. If the sum exceeds the block size, wrap the overflow back (modulo arithmetic)
4. Transmit the final sum as the checksum

Example calculation:

• Data bytes: 10110101, 11001010, 01110011
• Decimal values: 181, 202, 115
• Sum: 181 + 202 + 115 = 498
• If using 8-bit checksum with modulo 256: 498 mod 256 = 242
• Checksum (binary): 11110010

The receiver adds the same bytes and checks whether the result matches the transmitted checksum. Any discrepancy indicates an error.

Advantages of checksums:

• Detects multiple-bit errors more reliably than parity
• Can detect burst errors affecting consecutive bits
• Detects errors in data order or missing data blocks
• More robust than simple parity checking

Limitations of checksums:

• Requires more computation than parity bits
• Slightly increases data transmission overhead
• Cannot correct errors, only detect them
• Some error combinations may still go undetected (though rare)

Echo checking

Echo checking involves the receiver sending received data back to the sender for verification. The sender compares the echoed data with the original.

Process:

1. Sender transmits data to receiver
2. Receiver immediately sends the received data back to sender
3. Sender compares original data with echoed data
4. If they match, transmission was successful
5. If they differ, sender retransmits the data

This method is commonly used in:

• Terminal systems where typed characters are echoed to the screen
• Point-to-point communication links
• Critical systems requiring high reliability

Advantages of echo checking:

• Highly reliable error detection
• Confirms data reached the destination correctly
• No complex calculations required
• Verifies both transmission paths (sender to receiver and back)

Limitations of echo checking:

• Doubles the amount of data transmitted, using twice the bandwidth
• Takes twice as long as one-way transmission
• Inefficient for large data transfers
• Errors could occur in both directions, potentially masking problems
• Not suitable for high-speed networks where efficiency matters

Majority voting

Majority voting transmits the same data multiple times (usually three) and accepts the value that appears most frequently. This method assumes errors are unlikely to occur identically in multiple transmissions.

Process:

1. Sender transmits the same bit or byte three times
2. Receiver compares all three copies
3. The value appearing at least twice is accepted as correct
4. If all three differ, an error is reported

Example:

• Bit to transmit: 1
• Three transmissions: 1, 1, 0 (one error occurred)
• Receiver accepts: 1 (appears twice)

Advantages of majority voting:

• Can detect AND correct single errors without retransmission
• Effective when transmission is unreliable
• Simple logic to implement
• Useful in space missions and critical systems

Limitations of majority voting:

• Triples the data transmission (200% overhead)
• Very slow and inefficient
• Fails if two or more copies are corrupted identically
• Impractical for large data transfers
• Wastes significant bandwidth

Comparing error detection methods

Worked examples

Example 1: Even parity calculation (3 marks)

Question: A computer system uses even parity. Calculate the parity bit for the binary data 1010110. Show your working.

Model answer:

• Count the number of 1s in 1010110: four 1s [1 mark]
• Four is already an even number [1 mark]
• Therefore, the parity bit is 0 (to maintain even parity)
• Complete transmitted data: 10101100 [1 mark]

Example 2: Checksum detection (4 marks)

Question: A sender transmits three bytes of data with a checksum. The sender calculates the checksum as follows:

Byte 1: 10001001 (137) Byte 2: 01110100 (116) Byte 3: 10010110 (150) Transmitted checksum: 147

The receiver receives: Byte 1: 10001001 Byte 2: 01110100 Byte 3: 10010111

Explain whether an error has occurred. Show all calculations.

Model answer:

• Receiver adds the three received bytes: 137 + 116 + 151 = 404 [1 mark]
• Using modulo 256: 404 mod 256 = 148 [1 mark]
• Received checksum was 147, calculated checksum is 148 [1 mark]
• The values do not match, therefore an error has occurred. The receiver would request retransmission. [1 mark]

Example 3: Comparing methods (6 marks)

Question: A hospital transmits patient data from monitoring devices to a central computer system. The data must be accurate as it affects medical decisions.

Compare the use of parity checking and majority voting for this application. Recommend which method would be more suitable and justify your choice.

Model answer: Parity checking advantages: Fast transmission / Low overhead / Simple to implement [1 mark] Parity checking disadvantages: Only detects single-bit errors / Cannot correct errors / Must retransmit if error detected [1 mark]

Majority voting advantages: Can correct errors without retransmission / More reliable error detection / Suitable for critical data [1 mark] Majority voting disadvantages: Triples transmission time and data / Inefficient / Expensive to implement [1 mark]

Recommendation: Majority voting would be more suitable [1 mark] Justification: Patient safety is the priority and data accuracy is critical for medical decisions, so the extra reliability justifies the slower transmission speed [1 mark]

Common mistakes and how to avoid them

• Confusing error detection with error correction. Most methods only detect errors, not fix them. Only majority voting can correct errors automatically. In exam answers, be clear about whether a method corrects or just detects.

• Miscounting 1s in parity calculations. Always write out your working clearly. Count each 1 carefully, especially in longer binary strings. Remember the parity bit itself must be included in the final count.

• Thinking parity bits detect all errors. Parity only reliably detects single-bit errors. If two bits flip, the parity will appear correct. Always mention this limitation when discussing parity checking.

• Confusing even and odd parity. Even parity means the total number of 1s (including the parity bit) must be even. Odd parity means the total must be odd. Read questions carefully to identify which system is being used.

• Forgetting the practical implications. Echo checking doubles transmission time, majority voting triples it. When evaluating methods, always consider bandwidth, speed, and efficiency alongside reliability.

• Not showing calculations clearly. In checksum and parity questions, examiners award marks for working. Show each step: identify the data, perform calculations, state the result, and explain what it means.

Exam technique for "Data transmission: methods of error detection (parity bits, majority voting, checksums, echo checking)"

• "Calculate" questions require working. When asked to calculate a parity bit or checksum, show every step: count or add the values, explain the logic, state the final answer. Marks are often awarded for method, not just the correct answer.

• "Describe" means explain the process. When describing a method like echo checking, write the steps in sequence. Use command words like "first," "then," "finally" to structure your answer. Two marks typically means two distinct points.

• "Compare" requires both similarities and differences. When comparing two methods, give advantages and disadvantages of each. Structure your answer clearly, perhaps in two paragraphs, one per method. Four marks usually means two points per method.

• Application questions test understanding, not memorisation. When given a scenario (e.g., space probe, banking system), think about priorities: is speed or reliability more important? Justify your choice using specific features of the context provided.

Quick revision summary

Transmission errors occur when data is corrupted during transfer. Parity bits add one bit to make the total 1s even or odd, detecting single-bit errors quickly but with limitations. Checksums sum data blocks to detect multiple-bit and burst errors more reliably. Echo checking sends data back to the sender for comparison, providing high reliability but doubling transmission time. Majority voting sends data three times and accepts the most common value, enabling error correction but tripling overhead. Choose methods based on the balance between reliability, speed, and efficiency required for each application.