keepcalculator

06 Numbers and Powers

Turbo Grid Codes Explained: How They Work

Card No. 06·76661 · Updated · Standard formula, shown below

Turbo grid codes are a type of forward error correction (FEC) scheme used in digital communications to detect and correct errors introduced during transmission.

Background: Why Turbo Codes Exist

Turbo codes were introduced in 1993 by Claude Berrou and his colleagues. They were a breakthrough because they approached the Shannon limit—the theoretical maximum data rate for a given signal-to-noise ratio—more closely than any practical code before them. Before turbo codes, engineers used convolutional codes and Reed-Solomon codes, but these required either very long constraint lengths or produced diminishing returns. Turbo codes achieve strong error correction by using two (or more) relatively simple convolutional encoders in parallel, separated by an interleaver, and decoding iteratively. This structure allows the decoder to refine its estimates of the transmitted bits over several passes, producing very low error rates even in noisy channels.

How a Turbo Encoder Works

A typical turbo encoder consists of:

  • Two recursive systematic convolutional (RSC) encoders, each with a small constraint length (usually 3 or 4).
  • An interleaver, which reorders the input data bits before feeding them to the second encoder. The interleaver is crucial—it decorrelates the errors between the two encoders.
  • A puncturing unit (optional) that deletes some parity bits to increase the code rate.

The first encoder receives the data bits in their original order and produces parity bits. The same data bits are then interleaved (shuffled) and fed to the second encoder, which produces a second set of parity bits. The transmitted sequence consists of the original data bits (systematic part) followed by the parity bits from both encoders, possibly with some parity bits removed by puncturing.

How Turbo Decoding Works

Decoding a turbo code is an iterative process that uses two soft-input soft-output (SISO) decoders, one for each constituent code. The steps are:

  1. The receiver computes log-likelihood ratios (LLRs) for each received bit, representing the probability that the bit is 0 or 1.
  2. The first SISO decoder processes the LLRs using the first encoder’s trellis (a Viterbi-like algorithm, but with soft outputs, e.g., the BCJR algorithm). It produces extrinsic information—new reliability values for each data bit.
  3. The extrinsic information is interleaved and passed to the second SISO decoder, which processes the interleaved LLRs and produces its own extrinsic information.
  4. This extrinsic information is de-interleaved and fed back to the first decoder, and the process repeats.
  5. After several iterations (typically 4 to 8), the decoder makes a hard decision on each bit based on the accumulated LLRs.

Each iteration improves the reliability of the estimates, but the gains diminish after about 8 iterations. The iterative nature is what gives turbo codes their name—it resembles the feedback loop of a turbocharged engine.

Choosing Turbo Code Parameters

When designing a system that uses turbo codes, you need to decide on several parameters:

  • Code rate: Lower rates (e.g., 1/3) add more redundancy and correct more errors, but reduce throughput. Higher rates (e.g., 3/4) are more efficient but less robust.
  • Block size (k): Larger blocks generally improve performance because the interleaver can spread errors more effectively, but they increase latency and memory requirements.
  • Number of iterations: More iterations improve performance but increase decoding delay and power consumption.
  • Interleaver design: A well-designed interleaver (e.g., a quadratic permutation polynomial interleaver) avoids low-weight codewords that cause error floors.
  • Constituent encoder polynomials: The feedback and feedforward polynomials determine the code’s distance properties.

In practice, standards like LTE, DVB-RCS, and deep-space communications (CCSDS) specify fixed parameter sets, so you rarely choose these freely. But if you are designing a custom system, you would simulate different combinations to find the best trade-off between error rate, latency, and complexity.

Common Problems and Misconceptions

One common misconception is that turbo codes are always better than LDPC codes. In reality, for very large block sizes (e.g., 10,000+ bits), LDPC codes often achieve lower error rates with less decoding complexity. Turbo codes excel at moderate block sizes (hundreds to a few thousand bits) and are easier to implement with parallel decoding.

Another issue is the error floor: at high signal-to-noise ratios, the bit error rate of a turbo code may flatten out instead of continuing to drop. This is caused by low-weight codewords that the iterative decoder cannot resolve. Designers mitigate this by using larger interleavers, dithering, or concatenating an outer code (e.g., a CRC) to detect residual errors.

A practical problem is latency: turbo decoding requires multiple iterations, each involving forward and backward passes through the trellis. This makes turbo codes unsuitable for extremely low-latency applications like real-time control loops, where a single-pass convolutional code might be preferred.

Turbo Codes vs. Other FEC Schemes

Here is a quick comparison with other common error correction codes:

  • Convolutional codes (Viterbi): Simpler, lower latency, but weaker performance. Used in older systems like GSM.
  • Reed-Solomon: Works on symbols (bytes) rather than bits; great for burst errors (e.g., scratched CDs), but less efficient on Gaussian noise.
  • LDPC codes: Similar performance to turbo codes, often better for large blocks, and decode in parallel, making them faster in hardware. Used in Wi-Fi, 5G, and satellite TV.
  • Polar codes: The newest family, used in 5G control channels; they are provably capacity-achieving but require very long block lengths.

Turbo codes remain a solid choice when you need strong error correction with moderate block sizes and can tolerate some decoding latency.

Costs and Implementation Considerations

Implementing turbo codes has both computational and hardware costs:

  • Decoder complexity: Each iteration requires two BCJR decoders, each performing forward and backward recursion over the trellis. For a block of k bits and a trellis with S states, this is O(k × S) operations per iteration.
  • Memory: You need to store the received LLRs, extrinsic information, and the interleaver pattern. For large blocks, this can be significant.
  • Latency: As mentioned, iterative decoding adds delay. For real-time voice, this is usually acceptable (tens of milliseconds), but for high-speed data, it can be a bottleneck.
  • Power consumption: Iterative decoding consumes more energy than a single-pass decoder, which matters in battery-powered devices.

In exchange, you get a coding gain of several decibels over uncoded transmission, which can reduce required transmit power or increase range—often worth the cost.

Safety and Reliability Notes

Turbo codes are not a safety mechanism; they are a reliability feature. They reduce the probability of undetected errors, but they do not eliminate them. For critical applications (e.g., medical data, financial transactions), you should always add a strong CRC or other integrity check on top of the turbo code. Also, be aware that the iterative decoder can occasionally produce a “false convergence” where it outputs a valid codeword that is not the one sent—this is extremely rare but possible. Standards often include a CRC to catch such events.

Frequently Asked Questions

What is the main advantage of turbo codes?

The main advantage is their ability to operate very close to the Shannon limit, meaning they can achieve reliable communication at lower signal-to-noise ratios than older codes. This translates to better range, higher data rates, or lower transmit power for a given error rate.

Why are they called “turbo” codes?

The name comes from the iterative decoding process, which resembles the feedback loop in a turbocharged engine. The decoder feeds its output back into itself, refining the estimate each time, just as a turbocharger recycles exhaust gases to boost engine power.

Are turbo codes still used today?

Yes. They are used in 3G and 4G cellular networks (UMTS, LTE), satellite communications (DVB-RCS), and deep-space missions (NASA’s Mars rovers). However, 5G uses LDPC codes for data channels and polar codes for control channels, so turbo codes are less dominant in the newest standards.

What is the difference between turbo codes and LDPC codes?

Both are powerful FEC codes, but they use different structures. Turbo codes use two convolutional encoders with an interleaver and iterative decoding. LDPC codes use sparse parity-check matrices and belief propagation decoding. For large block sizes, LDPC codes often perform better and decode faster in parallel hardware; for small to medium blocks, turbo codes are competitive.

Can turbo codes correct burst errors?

Turbo codes are primarily designed for random errors (like those from AWGN channels). They can handle some burst errors if the interleaver spreads the burst across the block, but they are not as effective as Reed-Solomon codes for long bursts. For channels with frequent bursts (e.g., fading), you might combine a turbo code with an outer interleaver or a burst-erasure code.

How many iterations are needed?

Typically 4 to 8 iterations are enough to get most of the coding gain. More iterations give diminishing returns and increase latency. In practice, decoders often stop early if a CRC check passes, saving power.

Related

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.

More cards in this drawer

The whole Numbers and Powers drawer →