VRC and LRC: Understanding Vertical and Longitudinal Redundancy Check for Error Detection

error detection Methods

The video explains two error detection methods: Vertical Redundancy Check (VRC) and Longitudinal Redundancy Check (LRC).

Key Concepts:

• Vertical Redundancy Check (VRC)
  • Type: One-dimensional parity check.
  • Function: Detects single bit errors by appending an additional parity bit to the data.
  • Mechanism:
    • If the count of '1's in the data is odd, the parity bit is '1'; if even, it is '0'.
    • VRC cannot detect multiple bit errors (burst errors).
  • Example: For the ASCII value of 'A' (01000001), if the data has two '1's (even), the parity bit is '0', resulting in the final codeword being the data plus the parity bit.
  • Limitations:
    • Can only detect single bit errors; fails with burst errors (e.g., if two bits are erroneous, it may incorrectly indicate no error).
• Longitudinal Redundancy Check (LRC)
  • Type: Two-dimensional parity check.
  • Function: Can potentially detect multiple bit errors by calculating parity for both rows and columns of the data matrix.
  • Mechanism:
    • Data is arranged in a matrix format, and parity bits are calculated for each column.
    • Parity bits are sent along with the data.
  • Example: If two bits are modified, the LRC may still report no error if the parity bits do not change, but it generally has a higher capability to detect multiple errors compared to VRC.
  • Limitations:
    • Requires more redundancy bits, and it is not guaranteed to detect every multi-bit error.

Conclusion:

Both methods have their use cases and limitations. VRC is simpler and only detects single errors, while LRC is more robust but adds complexity and redundancy. The video emphasizes that while these methods are not commonly used in modern computer networks, they are still relevant for educational purposes.

Main Speaker:

The speaker provides an instructional overview and practical examples of VRC and LRC, aiming to clarify their workings and applications in error detection.