Line Coding Bipolar - Learning Module

Loading content...

0/228

Error Detection in Bipolar Coding

The Built-in Error Detector

One of the most valuable properties of bipolar encoding schemes is their inherent error detection capability. Unlike simpler encoding methods that require additional redundancy bits for error checking, AMI, B8ZS, and HDB3 provide error detection as a natural consequence of their encoding rules.

This built-in detection arises from a simple principle: bipolar schemes follow strict rules about polarity alternation. When these rules are violated—and the violation isn't part of a recognized substitution pattern—a transmission error has occurred. This allows real-time monitoring of link quality without any bandwidth overhead.

Understanding error detection in bipolar systems is essential for network operations, troubleshooting, and system design. It transforms abstract encoding theory into practical diagnostic capability.

What You Will Master

By the end of this page, you will understand how bipolar violations indicate errors, how B8ZS/HDB3 substitution patterns are distinguished from real errors, the types of errors that can and cannot be detected, and how production telecommunication systems use violation monitoring for link quality assessment.

The Bipolar Violation Concept

A Bipolar Violation (BPV) occurs when the fundamental rule of bipolar encoding is broken: two consecutive marks (non-zero pulses) have the same polarity instead of alternating.

The AMI rule:

Every mark must have opposite polarity to the previous mark
Violation: Two consecutive marks with same polarity

Visual representation:

Valid AMI:          +1  0  0  -1  0  +1  0  -1  +1
                     ↑        ↑     ↑     ↑   ↑
                    Alternating: + - + - +

With violation:     +1  0  0  +1  0  +1  0  -1  +1
                     ↑        ↑
                    Same polarity! BPV detected

Why violations indicate errors:

In a properly functioning transmission system:

The transmitter follows bipolar encoding rules exactly
Each mark strictly alternates polarity
Substitution patterns (B8ZS/HDB3) are correctly formed

If the receiver observes a violation that doesn't match a substitution pattern, something went wrong:

Noise: Random interference corrupted a pulse
Intersymbol interference: Pulse spreading caused incorrect detection
Equipment failure: Transmitter or receiver malfunction
Signal degradation: Cable or connector problems

Detection Without Overhead

The beauty of BPV detection is that it requires no additional bandwidth. Parity-based error detection adds redundancy bits; CRC adds check sequences. Bipolar violation detection uses information already present in the encoding structure—the polarity alternation rule—making it "free" in terms of overhead.

Distinguishing Intentional from Real Violations

The introduction of B8ZS and HDB3 created a complication: these schemes use intentional violations as markers for substitution patterns. Error monitoring systems must distinguish between:

Substitution violations: Part of B8ZS/HDB3 patterns (not errors)
True violations: Transmission errors requiring attention

Recognition rules:

Scheme	Substitution Pattern	How to Identify
B8ZS	000+-0-+ or 000-+0+-	Violations at positions 4 and 7 of 8-symbol pattern
HDB3	000V or B00V	Violations at position 4, with specific context
AMI	None	ALL violations are errors

violation_classifier.py
Python
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
class BipolarViolationClassifier:
    """
    Classifies bipolar violations as either substitution patterns
    or true transmission errors.
    """
    
    def __init__(self, encoding_type: str = "b8zs"):
        """
        encoding_type: 'ami', 'b8zs', or 'hdb3'
        """
        self.encoding_type = encoding_type.lower()
        
    def classify_violations(self, signal: list[int]) -> dict:
        """
        Scan signal for violations and classify each as
        substitution or error.
        """
        substitutions = []
        errors = []
        
        if self.encoding_type == "ami":
            # AMI: All violations are errors
            errors = self._find_all_violations(signal)
            
        elif self.encoding_type == "b8zs":
            # B8ZS: Check for 8-symbol substitution patterns
            violations = self._find_all_violations(signal)
            for v in violations:
                if self._is_b8zs_substitution(signal, v["position"]):
                    substitutions.append(v)
                else:
                    errors.append(v)
                    
        elif self.encoding_type == "hdb3":
            # HDB3: Check for 4-symbol substitution patterns
            violations = self._find_all_violations(signal)
            for v in violations:
                if self._is_hdb3_substitution(signal, v["position"]):
                    substitutions.append(v)
                else:
                    errors.append(v)
        
        return {
            "encoding_type": self.encoding_type,
            "total_violations": len(substitutions) + len(errors),
            "substitution_violations": len(substitutions),
            "true_errors": len(errors),
            "error_details": errors,
            "substitution_details": substitutions
        }
    
    def _find_all_violations(self, signal: list[int]) -> list[dict]:
        """Find all bipolar violations in signal."""
        violations = []
        last_polarity = None
        last_idx = None
        
        for i, level in enumerate(signal):
            if level != 0:
                if last_polarity is not None and level == last_polarity:
                    violations.append({
                        "position": i,
                        "polarity": level,
                        "previous_mark_position": last_idx
                    })
                last_polarity = level
                last_idx = i
        
        return violations
    
    def _is_b8zs_substitution(self, signal: list[int], v_pos: int) -> bool:
        """Check if violation at v_pos is part of B8ZS substitution."""
        # B8ZS patterns: 000+-0-+ or 000-+0+-
        # Violations at positions 4 and 7 (relative to pattern start)
        
        # Check if this could be position 7 of a pattern
        if v_pos >= 7:
            pattern_start = v_pos - 7
            if pattern_start + 8 <= len(signal):
                segment = signal[pattern_start:pattern_start + 8]
                if segment == [0, 0, 0, 1, -1, 0, -1, 1]:
                    return True
                if segment == [0, 0, 0, -1, 1, 0, 1, -1]:
                    return True
        
        # Check if this could be position 4 of a pattern
        if v_pos >= 3:
            pattern_start = v_pos - 3
            if pattern_start + 8 <= len(signal):
                segment = signal[pattern_start:pattern_start + 8]
                if segment == [0, 0, 0, 1, -1, 0, -1, 1]:
                    return True
                if segment == [0, 0, 0, -1, 1, 0, 1, -1]:
                    return True
        
        return False
    
    def _is_hdb3_substitution(self, signal: list[int], v_pos: int) -> bool:
        """Check if violation at v_pos is part of HDB3 substitution."""
        # HDB3 patterns: 000V or B00V
        
        # Check for 000V pattern
        if v_pos >= 3:
            if (signal[v_pos-3] == 0 and signal[v_pos-2] == 0 and 
                signal[v_pos-1] == 0):
                return True
        
        # Check for B00V pattern
        if v_pos >= 3:
            if (signal[v_pos-3] == signal[v_pos] and  # Same polarity
                signal[v_pos-2] == 0 and signal[v_pos-1] == 0):
                return True
        
        return False
 
 
# Demonstration
print("=== Violation Classification Demo ===\n")
 
# Signal with B8ZS substitution
b8zs_signal = [1, 0, 0, 0, 1, -1, 0, -1, 1, -1]  # Contains B8ZS pattern
classifier = BipolarViolationClassifier("b8zs")
result = classifier.classify_violations(b8zs_signal)
print(f"B8ZS signal: {b8zs_signal}")
print(f"Substitution violations: {result['substitution_violations']}")
print(f"True errors: {result['true_errors']}")
 
# Signal with actual error
error_signal = [1, -1, -1, 1, -1]  # Error at position 2
result = classifier.classify_violations(error_signal)
print(f"\nError signal: {error_signal}")
print(f"True errors: {result['true_errors']}")
print(f"Error details: {result['error_details']}") 

Types of Detectable Errors

Bipolar violation detection can identify certain types of transmission errors, but not all. Understanding the coverage is essential for system design.

Errors that CAN be detected:

Detectable Error Types
Error Type	Description	Detection Mechanism
Space→Mark (0→1)	A zero is corrupted to become a pulse	Extra pulse violates alternation
Polarity Reversal	Pulse polarity is flipped (+V→-V)	Same polarity as previous mark
Pattern Corruption	Substitution pattern is damaged	Partial pattern doesn't match valid form
Timing Errors (severe)	Sampling at wrong time detects wrong level	Misdetected pulses create violations

Errors that CANNOT be detected:

Undetectable Error Types
Error Type	Description	Why Undetectable
Mark→Space (1→0)	A pulse is corrupted to zero	Missing pulse doesn't violate rules
Double Adjacent Errors	Two consecutive bits are both wrong	Errors cancel out; pattern appears valid
Symmetric Corruption	Pattern corrupted to another valid pattern	Both patterns are valid bipolar
Complete Pattern Loss	B8ZS/HDB3 pattern becomes zeros	Appears as data zeros, not violation

Detection Probability

For random single-bit errors, BPV detection catches approximately 50% of errors (those that add a pulse or flip polarity). The 50% that convert pulses to zeros go undetected. This is why BPV monitoring is complemented by higher-layer error detection in production systems.

Error detection coverage analysis:

Possible single-bit errors in bipolar signal:

  Original    Error         Detected?
  ─────────────────────────────────────
  +1  →  0    Mark lost     ✗ No violation
  +1  →  -1   Polarity flip ✓ Same polarity as neighbor
  -1  →  0    Mark lost     ✗ No violation  
  -1  →  +1   Polarity flip ✓ Same polarity as neighbor
  0   →  +1   False mark    ✓ Breaks alternation
  0   →  -1   False mark    ✓ Breaks alternation (50% chance)

  Overall detection rate: approximately 50-66% of single-bit errors

Code Violation Metrics

Telecommunications standards define specific metrics for measuring and reporting code violations. These metrics provide standardized ways to assess link quality.

ITU-T G.821 Performance Parameters:

Standard Performance Metrics
Metric	Abbreviation	Definition
Errored Second	ES	Any second with ≥1 error
Severely Errored Second	SES	Second with BER > 10⁻³
Degraded Minute	DM	Minute with 10⁻⁶ < BER < 10⁻³
Unavailable Second	UAS	Consecutive SES ≥10 seconds
Availability	—	Percentage of non-UAS time
Code Violation	CV	Raw count of bipolar violations

performance_monitor.py
Python
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
from dataclasses import dataclass
from typing import List
from datetime import datetime, timedelta
 
@dataclass
class SecondStats:
    """Statistics for one second of monitoring."""
    timestamp: datetime
    bit_count: int
    error_count: int
    cv_count: int  # Code violations
    
    @property
    def ber(self) -> float:
        """Bit Error Rate for this second."""
        return self.error_count / self.bit_count if self.bit_count > 0 else 0
    
    @property
    def is_errored(self) -> bool:
        return self.error_count > 0
    
    @property  
    def is_severely_errored(self) -> bool:
        return self.ber > 1e-3
 
 
class PerformanceMonitor:
    """
    ITU-T G.821 compliant performance monitoring.
    
    Tracks error rates and calculates standard metrics.
    """
    
    def __init__(self, line_rate_bps: int = 2_048_000):
        self.line_rate = line_rate_bps
        self.seconds_history: List[SecondStats] = []
        self.uas_threshold = 10  # Consecutive SES for UAS
        
    def record_second(self, cv_count: int, 
                      estimated_errors: int = None) -> SecondStats:
        """
        Record one second of monitoring data.
        
        cv_count: Number of code violations detected
        estimated_errors: If None, estimate as 2*cv_count 
                         (assuming ~50% detection rate)
        """
        if estimated_errors is None:
            # Rough estimate: detected violations represent ~50% of errors
            estimated_errors = cv_count * 2
            
        stats = SecondStats(
            timestamp=datetime.now(),
            bit_count=self.line_rate,
            error_count=estimated_errors,
            cv_count=cv_count
        )
        self.seconds_history.append(stats)
        return stats
    
    def calculate_metrics(self, duration_minutes: int = 15) -> dict:
        """
        Calculate ITU-T G.821 metrics for recent history.
        """
        # Get relevant seconds
        cutoff = datetime.now() - timedelta(minutes=duration_minutes)
        relevant = [s for s in self.seconds_history 
                    if s.timestamp >= cutoff]
        
        if not relevant:
            return {"error": "No data in specified period"}
        
        total_seconds = len(relevant)
        
        # Count different categories
        es_count = sum(1 for s in relevant if s.is_errored)
        ses_count = sum(1 for s in relevant if s.is_severely_errored)
        
        # Count unavailable seconds (10+ consecutive SES)
        uas_count = 0
        consecutive_ses = 0
        for s in relevant:
            if s.is_severely_errored:
                consecutive_ses += 1
                if consecutive_ses >= self.uas_threshold:
                    uas_count += 1
            else:
                consecutive_ses = 0
        
        # Calculate availability
        available_seconds = total_seconds - uas_count
        availability = available_seconds / total_seconds if total_seconds > 0 else 0
        
        # Total CV count
        total_cv = sum(s.cv_count for s in relevant)
        
        return {
            "measurement_period_minutes": duration_minutes,
            "total_seconds": total_seconds,
            "errored_seconds": es_count,
            "severely_errored_seconds": ses_count,
            "unavailable_seconds": uas_count,
            "availability_percent": availability * 100,
            "total_code_violations": total_cv,
            "es_ratio": es_count / total_seconds,
            "ses_ratio": ses_count / total_seconds,
            "link_status": self._assess_link_status(es_count, ses_count, total_seconds)
        }
    
    def _assess_link_status(self, es: int, ses: int, total: int) -> str:
        """Assess overall link status."""
        es_ratio = es / total if total > 0 else 0
        ses_ratio = ses / total if total > 0 else 0
        
        if ses_ratio > 0.1:
            return "CRITICAL - Link failing"
        elif ses_ratio > 0.01 or es_ratio > 0.1:
            return "DEGRADED - Needs attention"
        elif es_ratio > 0.01:
            return "MARGINAL - Monitor closely"
        else:
            return "HEALTHY"
 
 
# Demonstration
print("=== Performance Monitoring Demo ===\n")
 
monitor = PerformanceMonitor(line_rate_bps=2_048_000)  # E1 rate
 
# Simulate 60 seconds of traffic with occasional errors
import random
for i in range(60):
    # Mostly clean, occasional errors
    cv = random.randint(0, 1) if random.random() > 0.1 else random.randint(5, 50)
    monitor.record_second(cv)
 
metrics = monitor.calculate_metrics(duration_minutes=1)
print("Performance Metrics:")
for key, value in metrics.items():
    print(f"  {key}: {value}")

Production Error Monitoring

In production telecommunications environments, error monitoring is continuous and feeds into network management systems. Understanding how this works helps engineers design and troubleshoot systems.

The monitoring hierarchy:

┌─────────────────────────────────────────────────────┐
│            Network Management System (NMS)          │
│         Receives alarms, generates reports          │
└────────────────────────┬────────────────────────────┘
                         │ SNMP/TL1/NETCONF
┌────────────────────────┴────────────────────────────┐
│              Element Management System              │
│         Aggregates from multiple devices            │
└────────────────────────┬────────────────────────────┘
                         │
┌────────────────────────┴────────────────────────────┐
│           Physical Layer Monitor (per link)         │
│      Real-time BPV counting, ES/SES tracking        │
└─────────────────────────────────────────────────────┘

Alarm thresholds:

Most equipment uses configurable thresholds to generate alarms:

Alarm Level	Typical Threshold	Action
Minor	ES ratio > 1%	Log for review
Major	SES ratio > 0.1%	Alert on-call engineer
Critical	SES ratio > 1% or UAS	Immediate investigation

Common error patterns and causes:

Error Pattern	Likely Cause	Troubleshooting
Steady low CV rate	Normal background noise	Monitor for changes
Spikes at specific times	External interference	Correlate with environmental factors
Gradual increase over weeks	Equipment degradation	Schedule maintenance
Sudden high rate	Cable damage, equipment failure	Physical inspection
Correlated with weather	Moisture ingress	Check cable route

Proactive Maintenance

Smart network operators don't wait for failures. By trending CV rates over time, degrading links can be identified and replaced during scheduled maintenance windows rather than emergency outages. BPV monitoring enables predictive maintenance strategies.

Error Localization Techniques

When errors are detected, localizing the source is crucial for efficient repair. Several techniques help narrow down the fault location.

Loopback testing:

Loopback tests help isolate whether the problem is in local equipment, the transmission path, or the remote equipment.

Local              Transmission Path            Remote
┌──────┐           ────────────────           ┌──────┐
│ TX   │──────────────────────────────────────│ RX   │
│      │                                      │      │
│ RX   │──────────────────────────────────────│ TX   │
└──────┘                                      └──────┘

Loopback types:

1. Remote loopback: Test full path
   TX→→→→→→→→→→→→→→→→→→→→→→→→→→→RX
   RX←←←←←←←←←←←←←←←←←←←←←←←←←←←TX
   
2. Local loopback: Test local equipment only
   TX──┐
      │ (loop at local interface)
   RX──┘

Localization Procedure

•Perform local loopback: If errors appear, local equipment is suspect
•Perform remote loopback: If errors appear but local test was clean, problem is in line or remote equipment
•Check near-end vs far-end errors: Some systems report which direction errors originate
•Segment testing: If path has repeaters/muxes, test each segment individually
•Physical inspection: Look for obvious damage, loose connectors, water ingress

Near-End vs Far-End Block Errors:

Some systems can distinguish:

NEBE (Near-End Block Error): Errors detected on received signal from far end
FEBE (Far-End Block Error): Errors reported back by far end about what they received

This helps identify whether the problem is with the transmitter or the receiver direction of the link.

CRC-Based Error Detection Enhancement

Because BPV detection only catches ~50% of errors, modern systems often layer additional error detection on top. The most common enhancement is CRC (Cyclic Redundancy Check) embedded in the frame structure.

T1 Extended Superframe (ESF) CRC:

In ESF framing (24 frames = 1 superframe):

6 bits of CRC-6 are distributed across the superframe
CRC covers 4,632 data bits per superframe
Provides ~100% detection of burst errors ≤6 bits

E1 CRC-4 Multiframe:

In E1 CRC-4 multiframe (16 frames = 1 multiframe):

4 CRC bits per submultiframe
CRC covers 2,048 bits per submultiframe
Provides robust error detection for E1 payloads

BPV vs CRC Error Detection
Property	BPV Detection	CRC Detection
Detection rate	~50% of bit errors	~100% of covered block errors
Overhead	None (inherent)	Bit payload for CRC
Detection latency	Immediate (per bit)	Per frame/block
Error location	Approximate (which violation)	Block only (not which bit)
Protocol layer	Physical	Data link

Complementary Detection

BPV and CRC provide complementary detection. BPV catches errors that change polarities immediately; CRC catches errors that BPV misses (like 1→0). Together, they provide nearly complete error visibility for the physical layer.

Implementation Considerations

Implementing robust error detection in hardware and software requires attention to several practical details.

Hardware considerations:

Hardware Implementation

•Threshold detection: Detect three levels (+V, 0, -V) with appropriate hysteresis to reject noise
•Polarity tracking: Maintain state for expected next polarity; XOR current with expected for violation
•Pattern matching: For B8ZS/HDB3, buffer enough symbols to recognize substitution patterns
•Counter saturation: CV counters must handle high error rates without overflow
•Timing alignment: Violation detection must be synchronized with bit clock

Software considerations:

Software Implementation

•Periodic polling: Read CV counters at regular intervals (typically 1 second)
•Delta calculation: Track changes since last read, not just absolute values
•Threshold comparison: Compare rates against configurable alarm thresholds
•Historical trending: Store long-term data for trend analysis
•Event correlation: Correlate errors across multiple links to identify common causes

cv_counter.py
Python
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
class CodeViolationCounter:
    """
    Hardware abstraction for code violation counter.
    
    In real systems, this would interface with hardware registers.
    """
    
    def __init__(self, counter_bits: int = 32):
        self.counter_bits = counter_bits
        self.max_value = (1 << counter_bits) - 1
        self._raw_count = 0
        self._last_read = 0
        self._rollover_count = 0
        
    def increment(self, count: int = 1):
        """Simulate hardware incrementing on CV detection."""
        new_value = self._raw_count + count
        if new_value > self.max_value:
            self._rollover_count += 1
            new_value = new_value - self.max_value - 1
        self._raw_count = new_value
        
    def read_and_clear(self) -> int:
        """
        Read counter and calculate delta since last read.
        Handles counter rollover correctly.
        """
        current = self._raw_count
        
        # Calculate delta with rollover handling
        if current >= self._last_read:
            delta = current - self._last_read
        else:
            # Counter rolled over
            delta = (self.max_value - self._last_read + 1 + current)
        
        self._last_read = current
        return delta
    
    def read_total(self) -> int:
        """Read total count including rollovers."""
        return self._rollover_count * (self.max_value + 1) + self._raw_count
 
 
# Example usage
counter = CodeViolationCounter(counter_bits=16)
 
# Simulate incoming violations
counter.increment(100)
reading1 = counter.read_and_clear()
print(f"First reading: {reading1} violations")
 
counter.increment(50)
counter.increment(25)
reading2 = counter.read_and_clear()
print(f"Second reading: {reading2} violations")

Summary: Error Detection Fundamentals

Error detection is one of the most practical and valuable properties of bipolar encoding schemes, enabling real-time link quality monitoring without overhead.

Key Takeaways

•Bipolar violations indicate errors when they don't match B8ZS/HDB3 substitution patterns
•~50% of single-bit errors are detectable via BPV; others require additional mechanisms
•ITU-T G.821 defines standard metrics (ES, SES, UAS) for quantifying link quality
•Production systems monitor continuously and generate alarms at configurable thresholds
•CRC complements BPV detection to achieve near-complete error visibility
•Loopback testing localizes whether errors originate in local, line, or remote equipment

What's next:

With our understanding of AMI, B8ZS, HDB3, and error detection complete, we'll now explore the real-world applications of these schemes. The next page covers T1/E1 Applications—how bipolar coding enables the backbone of telecommunications infrastructure that connects the world.

Page Complete

You now understand how bipolar encoding provides built-in error detection, how to distinguish substitution violations from real errors, and how production networks monitor link quality. This knowledge is essential for telecommunications operations and troubleshooting.