10 - Códigos Corretores Automáticos de Erro

10.1 - Introdução
O sistema mostrado na figura 10.1 ilustra a transmissão e a recepção de sinais que
utilizam a codificação e a decodificação para aumentar a qualidade do envio de dados.

Canal discreto

Codificador Modulador Forma de onda Detector Decodificador

do canal do canal do canal

Fonte Ruído Usuário

(discreta)

Figura 10.1 Comunicação digital com codificação das seqüências transmitidas.

O codificador do canal no transmissor recebe os bits contendo a mensagem e

adiciona redundância de acordo com uma regra pré-estabelecida, a codificação do código
corretor. Na decodificação, a redundância é explorada de forma a decidir quais bits de
mensagem foram de fato transmitidos. A grande vantagem da codificação e decodificação
do canal é minimizar o efeito do ruído, ou seja, diminuir o número de erros entre a entrada
do codificador (a fonte de dados) e a saída do decodificador (entrega ao usuário).

Para um dado esquema de modulação, a adição de redundância nas mensagens

codificadas requer aumento da largura de banda. Além do mais, a utilização de códigos
corretores de erro torna o sistema mais complexo, principalmente nas operações de
decodificação no receptor. Assim, o desafio ao utilizar códigos corretores de erro é atingir
um de erro aceitável levando em consideração fatores como a largura de banda e a
complexidade do sistema.

Quando temos como interesse principal a eficiência da largura de banda, o método

mais efetivo de implementarmos a codificação é combinando-a com a modulação como
mostrado na Figura 10.2.

183
 Codificador/Modulador Forma de onda Detector/Decodificador
do canal

Fonte Ruído Usuário

(discreta)

Figura 10.2 Modulação e codificação combinadas.

Existem diversos códigos corretores de erros classificados em códigos de bloco e

códigos convolucionais. A característica determinante desta classificação é a presença ou
não de memória nos codificadores dos dois tipos de códigos.

10.2 Codificação Linear em Blocos (“Linear Block Codes”)

O codificador recebe blocos de k bits e adiciona a estes blocos de símbolos, n-k

bits, formando então um novo código contendo n bits. Dessa forma geramos uma
codificação linear em blocos (n, k), n > k. A fonte produz símbolos à taxa de RS “bit rate” e

n
o codificador, à taxa de R 0 =   R S “bit rate”, a qual é chamada de taxa do canal.
k

Formação do Código Linear (n, k)

Seja m0, m1, m2, …, mk-1 um bloco de k bits arbitrários de informação, ou seja,
podemos ter 2k possíveis mensagens de k símbolos. Seja b0, b1, …, bn-k-1 bits de paridade
para formação do código de n bits totais. Arrumemos estes bits da seguinte forma:
b0 b1 b2 … bn-k-1 m0 m1 m2 … mk-1 (10.1)

formando a palavra código

x0 x1 x2 ................................. xn-1.
ou seja:

b i = 0, 1, , n - k - 1
xi =  i
m i + k - n i = n - k, n - k + 1, L, n - 1 (10.2)

184
 Os n-k bits de paridade são somas lineares dos k bits de informação dado por:

bi = pi0 m0 ⊕ pi1 m1 ⊕ pi2 m2 ⊕ … ⊕ pi.k-1 mk-1 (10.3)

i = 0, 1, 2, …, n-k-1 ⊕ → soma módulo 2

1 se b i depend de m j
onde pij = 
0 se não depende
Definindo em termos de vetores, tem-se:

m = [m 0 , m1 ,... , m k -1 ]
~ (10.4)

b = [b 0 , b1 , , b n - k -1 ]
~ (10.5)

x = [x 0 , x1 , ... , x n -1 ]
~ (10.6)

onde m, b e x são vetores linhas.

~ ~ ~

Pode-se então representar b como combinação linear de m como:

b=mP
~ ~ (10.7)
onde

 p00 p10 L pn -k -1,0  ⇐ m0

p p11 L pn -k -1,1  ⇐ m1
P= 
01
 M M M  M
 
p0,k -1 p1,k -1 L pn -k -1,k -1  ⇐ mk -1
coeficiente dos bits ↑ ↑ ↑
b0 b1 L bn -k -1 (10.8)

185
 x =  b, m 
~  ~ ~  (10.9)
Logo:

[
x = m P, m = m[P, I k ]
~ ~ ~
] ~ (10.10)

onde
P é uma matriz k por (n-k)

1 

0 0 ... 0
Ik = 0 

1 ... 0 matriz unitária de ordem k
:  : ... 

0  0 ... 1
(10.11)
Define-se a matriz geradora k x n, como:

G = [P, I k ] (10.12)

ou seja, x = m.G
~ ~

m tem 2k possíveis mensagens

~

x é uma palavra código

~

- Propriedade de fechamento
A soma de duas palavras código é outra palavra código

 
x i ⊕ x j = m i G ⊕ m j G =  m i ⊕ m j G
~ ~ ~ ~  ~ ~  (10.13)

186
mi ⊕ m j representa uma nova mensagem
~ ~
Definição: Matriz de “check” de paridade, H

[
H = In -k , PT ] (n - k) x n (10.14)

PT é a matriz transporta de P e In-k é uma matrix unitária de ordem n-k.

Tem-se que:

T
[
H G = In -k , P T
] P T 
 
 Ik 
G = [Pk, n - k , I k ]
P é matriz j, n-k; PT é n-k x k

H G T = I n - k, n - k PnT- k, k + PnT- k, k I k, k

H GT = PT + PT = matriz nula = 0n-k,k

H GT = 0 (10.15)

Equivalentemente, G HT = 0k,n-k. Como x = m G , tem-se

~ ~

x H T = m G H T = 01, n - k
~ ~

x HT = 0
~ (10.16)

Síndrome: s
~

A matriz G é usada no transmissor para gerar o vetor x que é a palavra código

~
transmitida. A matriz H é usada no receptor para decodificar o sinal recebido da seguinte

187
forma: suponha que recebamos g que é igual ao x (palavra código) mais um erro e
~ ~ ~

(vetor erro)

y=x⊕e
~ ~ ~
(10.17)

e = [e1 e 2 L e n ]
~ (10.18)

1 se existe um erro na i - ésima posição

onde ei = 
0 se não existe erro

A síndrome s é calculada como:

~

s = y . H T =  x + e  . H T = x H T ⊕ e H T
~ ~  ~ ~ ~ ~
(10.19)

s = e HT
~ ~ (10.20)

Propriedades da síndrome s:
~

1a.) s = e . HT
~ ~
A síndrome só depende do vetor erro.

2a.) Para um determinado erro fixo, e , todas as 2k palavras códigos x , a síndrome é a

~ ~
mesma

e1 = e ⊕ x i i = 0, 1, L, 2 k - 1
~ ~ ~ (10.21)

188
 e1 H T = e . H T ⊕ x i H T = e H T
~ ~ ~
~ (10.22)
Os possíveis vetores ei, i = 0, 1, 2, …, 2k-1 que produzem a mesma síndrome, são
chamados de coset.

Como x tem n elementos, teremos 2n palavras possíveis, ou seja, 2n ÷ 2k = 2n-k

~
possíveis cosets.

3a.) A síndrome s é a soma de todas as colunas da matriz H correspondendo às posições

~
dos erros

 
H =  h1 h 2 ... hn 
~ ~ ~  (10.23)

h1T 
~ 
h T 
s = e H T = [e1 e 2 e n ] ~ 
2
~  
 T
h n 
~  (10.24)
n
s = ∑ ei h iT
~ i =1 ~ (10.25)

e h iT é a i-ésima linha da matriz HT.

4a.) Utilizando-se a síndrome s , um código linear (n, k) pode corrigir até t erros na palavra
~

código x , desde que satisfaça ao limite de Hamming, dado por

~

t
2 n - k ≥ ∑ Cin
i=0 (10.26)

189
 Nesse limite, quando há igualdade, o código é chamado de perfeito.

Para se mostrar em limite, vê-se que existem n-k bits redundantes. Logo esses bits
podem apontar até 2n-k erros (síndromes). Como nosso código tem n bits e queremos

corrigir até t erros, ou seja, para se identificar que não há erro precisamos de C0n = 1
palavra + identificar 1 erro precisa-se de C1n = n palavras + identificar 2 erros precisa-se

n(-1)
de C 2n = palavras, etc.... até identificar t erros, precisamos CTn .
2

Logo:

C 0n + C1n + ... + C nt ≤ 2 nk (10.27)

Das propriedades de s , segue-se o seguinte algoritmo de decodificação:

~

1. Do sinal recebido y (palavra código), calcula-se a síndrome s,

~

onde s = y HT (10.28)

2. Para um determinado erro fixo, e , todas as 2k palavras códigos x , a síndrome é a

~ ~
mesma

e1 = e ⊕ x i i = 0, 1, L, 2 k - 1
~ ~ ~

e1 H T = e . H T ⊕ x i H T = e H T
~ ~ ~
~

190
 Os possíveis vetores ei, i = 0, 1, 2, …, 2k-1 que produzem a mesma síndrome, são
chamados de coset.

Como x tem n elementos, teremos 2n palavras possíveis, ou seja, 2n ÷ 2k = 2n-k

~
possíveis cosets.

3. A síndrome s é a soma de todas as colunas da matriz H correspondendo às posições

~
dos erros

 
H =  h1 h 2 L h n 
~ ~ ~ 

h1T 
~ 
h T2 
s = e H T = [e1 e 2 L en ]  ~ 
~ M 
 T
h n 
~ 

n
s = ∑ ei h iT
~ i =1 ~

e h iT é a i-ésima linha da matriz HT.

4a.) Utilizando-se a síndrome s , um código linear (n, k) pode corrigir até t erros na palavra
~

código x , desde que satisfaça ao limite de Hamming, dado por

~

191
 t
n -k
2 ≥ ∑ Cin
i =0

Nesse limite, quando há igualdade, o código é chamado de perfeito.

Para se mostrar em limite, vê-se que existem n-k bits redundantes. Logo esses bits
podem apontar até 2n-k erros (síndromes). Como nosso código tem n bits e queremos

corrigir até t erros, ou seja, para se identificar que não há erro precisamos de C0n = 1
palavra + identificar 1 erro precisa-se de C1n = n palavras + identificar 2 erros precisa-se

n(-1)
de C 2n = palavras, etc.... até identificar t erros, precisamos CTn .
2

Logo:

C0n + C1n + L + C nt ≤ 2 nk

Das propriedades de s , segue-se o seguinte algoritmo de decodificação:

~

1. Do sinal recebido y (palavra código), calcula-se a síndrome s; s = y HT

~

2. Da síndrome s , escolhe-se o erro e 0 que tem a maior probabilidade de produzir tal

~ ~
síndrome.

3. Como y = x̂ ⊕ e 0 , onde x̂ é a palavra código estimada (estimativa da que foi

~ ~ ~
transmitida).

192
 Logo a saída será x̂ = y ⊕ e 0
~ ~

(2) Considerações sobre distância mínima

 
A distância entre duas palavras códigos x e y, d x, y  , é dada pelo número de
~ ~ ~ ~

posição (bits) diferentes entre x e y. É claro que xey têm o mesmo número de
~ ~ ~ ~
posições (no caso n posições).

Outra definição: peso de Hamming w( x ) : é igual ao número de elementos

~

diferentes de zero. Equivalentemente, w( x ) = d( x , 0) .

~ ~ ~
Exemplo 10.1:

x = [1 0 1 0 0 0 1] y = [1 1 0 0 1 1 0 0]
~

d( x , y) = 5 w( x ) = d( x , 0) = 3
~ ~ ~ ~ ~

w( y) = d( y, 0) = 4 0 = [0 0 0 0 0 0 0 0]]
~ ~ ~

Dada todas as possíveis palavras códigos, a distância mínima é a menor distância

obtida entre quaisquer duas palavras códigos.

   
d min = w  x i - x j  = w  x i ⊕ x j 
~ ~ ~ ~  (10.29)

193
 Como, pela propriedade de fechamento, xi ⊕ x j é outra palavra código, então
~ ~

 
para se achar dmin basta achar a menor w  x  i = 0, 1, L desde que x i ≠ 0 .
 ~
 ~  ~

Como x H T = 0 , segue que, x tem que ter 1S em posições tais que as linhas de
~ ~ ~
H somam zero. Como o número de 1S significa a distância de Hamming, logo a distância
T

mínima de um código linear (n, k) é o menor número de linhas de HT que somem zero.

Se desejamos corrigir até t erros, a distância mínima tem que ser maior ou igual a
2t + 1, isto é,
dmin ≥ 2t = 1 (10.30)

Exemplo 10.2: Seja as possíveis palavras códigos x1 e x 2

~ ~

x1 = (0 0 0) x 2 = (1 1 1)
~ ~

 
d x1 , x 2  = 3
~ ~ 

Se recebermos y1 = (0 0 0) ou y 2 = (1 1 1)
~ ~

Temos:

   
d x1 , y1  = 0 d  x1 , y 2  = 3
~ ~ ~ 

194
    
d x 2 , y 2  = 3 d x 2 , y 2  = 0
 ~ ~   ~ 
Se recebermos:
y 3 = (0 0 1) y 4 = (0 1 0) y 8 = (1 0 0)
~ ~ ~

y 6 = (1 1 0) y 7 = (1 0 1) y 8 = (0 1 1)
~ ~ ~

Temos:
     
d x1, y 3  = d x1, y 4  = d x1, y 5  = 1
 ~ ~   ~ ~   ~ ~ 

     
d x1, y3  = d x1, y3  = d x1, y5  = 2
 ~ ~   ~ ~   ~ ~ 

     
d x 2, y3  = d x 2, y4  = d x 2, y5  = 2
 ~ ~   ~ ~   ~ ~ 

     
d x 2, y3  = d x 2, y7  = d x 2, y5  = 1
 ~ ~   ~ ~   ~ ~ 

Vemos então que a distância 1 tem muito maior probabilidade de acontecimento do

que a distância 2. Então podemos corrigir até um erro com uma determinada probabilidade.
Para isso, a distância mínima foi 3.

Se o receptor obtém um valor de y , conforme mostrado na figura 10.3, qual o valor de x a

ser escolhido?

195
Figura 10.3 – Possibilidades de duas palavras códigos xi e xj e uma
palavra código y recebida.

No terceiro caso, o y recebido tem distância idêntica para x i e x j . Qual x escolher ?

~ ~ ~
~

1
t= (d min - 1)
2 (10.31)
onde t é um inteiro.

O conjunto completo de palavras-código, conhecido também simplesmente como o

código, é gerado de acordo com a equação de definição. Neste código teremos
2 k seqüências de mensagem possíveis gerando 2 k palavras possíveis. É importante notar
que temos “disponíveis” 2n palavras-código num bloco de n bits, mas a questão é que
cada elemento do conjunto de 2 k mensagens só pode gerar 2 k palavras.

196
 2k CODIFICA
2k

Conjunto de seqüências possíveis 00000 0000000000000 Conjunto de palavras associadas às

para mensagens de k bits 01010
01011
0101011100101
0101011100101
mensagens
01011 0101011101010
01011 0101011101010

x=mG
Figura 10.4 Relação de uma mensagem de informação para uma palavra codificada.

Então, na codificação, ou seja, antes dos bits serem transmitidos pelo canal, temos
2 k seqüências de bits possíveis de serem enviadas. Será o erro na transmissão que fará
com que essas seqüências não pertençam mais a esse grupo e ficará a cargo do receptor
recuperar a mensagem “devolvendo-a” ao conjunto de 2k palavras, com ou sem erro. A
relação, obviamente, deve ser de um para um: uma palavra corresponde a somente uma
mensagem.

2n

2k 2k
Codificação realizada.
Transmissão pelo canal Conjunto de todas as seqüências
possíveis para blocos de n bits

ENVIO NO CANAL

Exemplo:

01100101
n − k
2k 2
01101101

Os erros que ocorrem no envio fazem Conjunto de seqüências que

palavras codificadas irem para fora do correspondem a uma mensagem
transmitida
conjunto mapeado

Figura 10.5 Como ocorre o erro na perspectiva dos códigos de bloco lineares.

197
Exemplo 10.3: Código de Hamming

É uma família de códigos tal que:

comprimento de código: n = 2m-1
número de bits de mensagem: k = 2n – 1 – m
número de bits de paridade: m = n – k
onde m ≥ 3.

O código de Hamming com n = 7 e k = 4, correspondendo a m = 3 é um código

linear (7, 4).

A matriz geradora G é dada por:

1 1 0 1 0 0 0
0 1 1 0 1 0 0
G= 
1 1 1 0 0 1 0
 
1 0 1 0 0 0 1
P Ik (10.32)

A matriz H correspondente é:

1 0 0 1 0 1 1
H = 0 1 0 1 1 1 0
 
0 0 1 0 1 1 1
In -k PT (10.33)

198
Com k = 4 temos 24 = 16 possíveis palavras códigos
Tabela 10.1 Mensagens e palavras códigos
Mensagem Palavra Peso Mensagem Palavra código Peso
código
0000 000 0000 0 1000 110 1000 3
0001 101 0001 3 1001 011 1001 4
0010 111 0010 4 1010 001 1010 3
0011 010 0011 3 1011 100 1011 4
0100 011 0100 3 1100 101 1100 4
0101 110 0101 4 1101 000 1101 3
0110 100 0110 3 1110 010 1110 4
0111 001 0111 4 1111 111 1111 7

dmin = 3, logo corrige até um erro

Tabela 10.2 Síndromes relacionadas aos códigos da tabela 10.1

Tipo de erro Padrão de erro Síndrome correspondente
sem erro 0000000 000
1 erro no 10. bit 1000000 100
1 erro no 20. bit 0100000 010
1 erro no 30. bit 0010000 001
1 erro no 40. bit 0001000 110
1 erro no 50. bit 0000100 011
1 erro no 60. bit 0000010 111
1 erro no 70. bit 0000001 101

Como n - k = 3 temos 23 possíveis síndromes

199
10.3 - Códigos Cíclicos

Os códigos ciclicos são uma subclasse dos códigos lineares tal que apresentam uma
propriedade cíclica da forma.

Seja (x0 x1 x2 ... xn-1) uma palavra código de um código linear (n, k), então
(xn-1, x0, x1, …, xn-2) também é uma palavra código. Da mesma forma serão palavras
códigos (xn-2,xn-1,x0,x1,…,xn-3) (xn-3,xn-2,xn-1,x0,x1,x2,…,xn-4), etc. … etc., … (x1 x2 … x0).
Estes códigos sugerem o tratamento por polinomios de grau (n-1), da forma:
x(D) = x0+x1D + x2D2 + … + xn-1Dn-1 onde D é um real qualquer. x(D) é chamado de
polinômio de palavra código.

x1(D) = a0 + a1b + a2D2

x2(D) = b0 + b1D + b2D2
x1(D) ⊕ x2(D) = a0 ⊕ b0 + (a1 ⊕ b1)D + (a2 ⊕ b2) D2
x1(D) . x2(D) = a0.b0 + a0.b1D + a0.b2D2 + … + a2 b2 D4

Se x(D) tem grau n-1, então

x(D) = x0 + x1D + x2D2 + … + xn-1Dn-1

Dx(D) = x0D + x1D2 + x2D3 + … + xn-1Dn
= xn-1 + x0D + x1D2 + … + xn-2Dn-1
Propriedade cíclica: multiplicação por D cria um deslocamento no tempo de 1 bit, com a
restrição que Dn = 1 para que xn-1Dn = xn-1, logo será o primeiro elemento do polinômio
(elemento independente de potência de D).

x(D) = x0 + x1D + x2D2 + x3D3

Dx(D) módulo (Dn-1) = x0D + x1D2 + x2D3+x3D4 mod(D4-1)
= x1D4 + x2D3 + x1D2 + x0D D4-1
 x2D4 + x1
x2D3 + x1D2 + x0D + x3

200
 Logo: Dx(D) mod(D4-1) = x3 + x0D + x1D2 + x2D3

Também, D2x(D) mod(D4-1) = x2 + x3D + x0D2 + x1D3

porque:

x3D5 + x2D4 + x1D3 + x0D2 D4-1

- x3D5 + x3D x3D + x2
x2D4 + x1D3 + x0D2 + x3D
-x2D4 + x2
x1D3 + x0D2 + x3D + x2

10.3.1 Polinômio gerador

O polinômio palavra código x(0) de grau n-1 de um código linear (n,k), contém um
polinômio de grau mínimo (n-k) como um de seus fatores.

Este polinômio mínimo é simbolizado como g(D) e chamado de polinômio gerador.

Este polinômio tem grau igual ao número de bits de paridade, e é equivalente a matriz
geradora G.

Propriedades de g(D):

1) O polinômio gerador de um código cíclico (n, k) é o único polinômio palavra

código de grau n-k

Para se provar, assume-se que possa existir outro polinômio de grau n-k. Somando-se
estes dois criaríamos outros polinômios que também seria palavra código. Porém a
soma dos polinômios, criaria um outro de grau menor. Logo, o polinômio g(D) é único.
Daí, vemos que para um polinômio ter ordem n-k, ele terá que ter obrigatoriamente o
termo independente de D e o termo em Dn-k, ou seja:

201
 n - k -1
g(D) = 1 + ∑ g i D n + D n - k
i =1 (10.34)
onde gi assume valores 0 ou 1, a serem determinados.

2) Qualquer múltiplo de g(D) é um polinômio palavra código

x(D) = a(D) g(D) mod(Dn-1)

onde a(D) é um polinômio qualquer. Pela propriedade cíclica e pela propriedade de

fechamento, vemos que a(D) g(D) tem grau n-1 e que é palavra código, então
x(D) = g(D).a(D).

A sequência de informação é dada por (m0 m1 … mk-1) e a palavra código x(D)

conterá mais n-k bits de paridade formando então a seguinte sequência

b 0 b1 .......... b n-k-1 m0 m1 ........ m k-1

n-k bits de paridade k bits de informação

ou seja, x(D) = b0 + b1D + … + mk-1 Dn-1

Com m(D) = m0 + m1D + … + mk-1Dk-1 tem-se que

m(D) . Dn-k = m0Dn-k + … + mk-1Dn-1

Dividindo-se m(D) Dn-k po g(D), tem-se:

D n - k m(D) b(D)
= a(D) +
g(D) g(D)

onde a(D) é quociente e b(D), o resto da divisão acima.

Ou ainda: Dn-km(D) = a(D) . g(D) + b(D) onde a(D) = a0 + a1D = … + ak-1 Dk-1 já
que a(D) multiplicado por g(D) (que tem ordem n-k), terá que ser de ordem n-1.

202
 Como b(D) é o resto da divisão, poderá ter no máximo grau n-k-1,
b(D) = b 0 + b1D + b 2 D 2 + ... + b n-k-1 D n-k-1

Podemos escrever também:

b(D) + Dn-km(D) = a(D) . g(D)

logo x(D) = b(D) +Dn-km(D).

Em resumo, existem três procedimentos para se obter uma estrutura sistemática de

um código cíclico linear (n,k):

a. Multiplique m(D) por Dn-k

b. Divida m(D) Dn-k por g(D), obtendo b(D)
c. Some b(D) a m(D) Dn-k obtendo o polinômio palavra código x(D).
7.3.1 Polinômio de cheque de paridade h(D)

Da relação H GT = 0 ou G HT = 0, tem-se: h(D) g(D) mod(Dn-1) = 0 já que g(D) é

equivalente a G e h(D) é equivalente a H, matrizes geradoras e de cheque de paridade,
respectivamente.

Da propriedade 2, qualquer múltiplo de g(D) de um código cíclico (n, k) é um

polinômio palavra código.

Então existe a seguinte relação:

h(D) x(D) mod(Dn-1) = 0

Como em aritmética módulo 2, 1-Dn, é idêntico a 1+Dn, deduz-se a seguinte

propriedade:

203
3a. propriedade:

Os polinômios g(D) e h(D) são fatores do polinômio 1+Dn,

h(D) g(D) = 1 + Dn (10.35)

Esta propriedade é quem fornece a base para obtenção de g(D) e h(D).

Se n é grande, haverão diversos fatores de 1+Dn de grau n-k.

Todos os fatores de 1+Dn de grau n-k podem ser usados como funções geradoras
g(D) de um código cíclico linear (n,k). O mesmo se aplica a h(D) de grau k.

Exemplo 10.4: Revisão dos códigos de Hamming

Suponha que desejamos gerar um código cíclico (7,4). n=7, k=4, n-k=3.

Fatorando 1+D7 em polinômios irredutíveis:

1 + D7 = (1+D) (1 + D2 + D3) (1 + D + D3)

O polinômio é dito irredutível quando é fatorado em polinômios cujos coeficientes

são binários (0 ou 1).

Um polinômio irredutível é dito primitivo de ordem m quando o menor n positivo

inteiro para o qual este polinômio divide 1+Dm-1.

Neste caso, 1+D2+D3 e 1+D+D3 são primitivos.

204
 Usemos, neste exemplo,

g(D) = 1 + D + D3

Logo h(D) = (1+D) (1+D2+D3) = 1 + D + D2 + D4

Da propriedade 1, g(D) e múltiplos de g(D) representam palavras código, logo

g(D) = 1 + D + D3
Dg(D) = D + D2 + D4 Linhas de G que é k x n
D2g(D) = D2 + D3 + D5
D3g(D) = D3 + D4 + D6

Então:

1 1 0 1 0 0 0
0 1 1 0 1 0 0
G= 
0 0 1 1 0 1 0
 
0 0 0 1 1 0 1

Colocando-se as quatro últimas colunas como matriz identidade:

1 1 0 1 0 0 0
0 1 1 0 1 0 0
G= 
1 1 1 0 0 1 0
 
1 0 1 0 0 0 1

Para se achar H tira-se a matriz P de G e como

H = [In-k, PT], tem-se:

205
 1 0 0 1 011
H = 0 1 0 1 110
0 0 1 0 111

10.3.5 Codificador/Decodificador de Códigos Cíclicos

A implementação desses códigos pode ser feita através de filtros FIR (Finite
Impulse Response) não recursivos.

As figuras 10.5 e 10.6 mostram o codificador e o decodificador (calculador de

síndrome):

Code
word

Message bits
Figura 10.5 Codificador de código bor bloco usando o polinômio
g(D) = 1+ g1 D1 + g2 D2 + .... + gn-k-1 Dn-k-1 + gn-k Dn-k

206
Figura 10.6 Cálculo da síndrome do código por bloco usando
g(D) = 1+ g1 D1 + g2 D2 + .... + gn-k-1 Dn-k-1 + gn-k Dn-k

Tb – memória para armazenar 1 bit que é enviado para frente por controle do “clock” (não
mostrado na figura)
Memória = shift – register = flip-flop = delay element

1 - conecção direta
gi =  → multplicadores
 0 - sem conecção
⊕ → somador módulo 2

Os valores de gi são tirados do polinômio g(D) = 1 + g1D + g2D2 + … + gn-k-1Dn-k-

1
+ Dn.

207
Figura 10.7 Decodificador (calculador da síndrome) de g(D) = 1+ D1 + D3

Observação: Função do gate é deixar ou não os bits passarem

Exemplo 10.5: Codificador para o código (7,4) g(D) = 1+D+D2

Figura 10.8 - Codificador do exemplo 10.5

Exemplo 4: Codificador para o código (7,4) g(D) = 1+D+D2

208
 Suponha que os bits de mensagem sejam 0011. Então a palavra código deverá ser
0100011.

Vejamos como funciona. Os bits entram da direita para a esquerda e a tabela abaixo
mostra as entradas e o conteúdo de cada registro (numerador em ordem crescente da
esquerda para a direita).

Tabela 10.3

Deslocamento Entrada Conteúdo dos registros Saída

(Shift)
0 0 0
1 1 1 1 0 1
2 1 1 0 1 1
3 0 1 0 0 0
4 0 0 1 0 0
x 0 0 1 1
x 0 0 0 0
x 0 0 0 0

209
10.4 Códigos Convolucionais

10.4.1 - Introdução
Nos códigos lineares por blocos, o xosificador espera k bits e gera, a partir destes k
bits, uma palavra código de n bits (n > k). Existem aplicações, onde os bits não chegam em
blocos e dessa forma há necessidade de se ter “buffers” e esses “buffers” podem ser
indesejáveis tendo em vista o formato e/ou rapidez de transmissão.

Nestes casos, existe uma outra maneira de se fazer códigos controladores de erro.
Tais códigos são chamados de códigos convolucionais.

O codificador convolucional opera em cada bit (ou bits) entrante e gera a palavra
código a partir desse bit.

1
O codificador de um código convolucional com taxa medida em bits por
n
símbolo, é um filtro digital que consiste de M-memórias (M shift registers) com n
conecções de “somadores módulo-2”, e um multiplexador que serializa as n saídas dos
somadores. Uma mensagem de L bits produz uma saída codificada de n(L+M) bits. A taxa

L
de código (code rate) é r= bits/símbolo. Como L >> M tem-se
n (L + n )
1
r ≅ bits/símbolo.
n

Existe um parâmetro chamado de “comprimento de restrição” (constraint lenght)

dos códigos convolucionais expresso em termos dos bits de mensagens. É definido como o
número de deslocamento (shifts) sobre o qual sem bit pode influenciar os códigos de saída.
Num codificador com M estágios de saída. Num (shift-registers), K = M+1 “shifts” são
necessários para 1 bit entrar e sair do codificador. Então, o comprimento de restrição é
igual a K.

As Figuras 10.9 e 10.10 mostram dois codificadores para códigos convolucionais.

210
Toda a teoria de códigos convolucionais mostrada nesse item usa como base o codificador
da figura 10.9.

1
Figura 10.9 – Constante de restrição k = 3; taxa =
2

2
Figura 10.10 – Constante de restrição k = 2, taxa =
3

211
10.4.2 Método do domínio do tempo

1
Códigos convolucionais de taxa têm comportamento no domínio do tempo
n
definido em termos de um conjunto de n amostras da respista impulsional. No caso da
figura 9 tem-se um filtro FIR de comprimento n = 3 amostras. Denotamos as amostras da

saída do braço superior de g (1) (1) (1) (1)

0 , g1 , g 2 , L g M e a do braço inferior de

g (2) (2) (2) (2)

0 , g1 , g 2 , L g M .

Nesse caso tem-se: g (1) = [1,1,1] g (2) = [1,0,1] .

~ ~

Esses vetores são chamados de sequências geradoras do código.

m = [m 0 , m1 , m 2 , ]
Seja uma sequência de mensagem ~ que entra no
codificador. O codificador gera duas sequências de saída (na figura 9 chamadas por

x (1 ) e x ( 2 ) . A saída será a convolução da entrada com a resposta impulsional. Logo

~ ~
teremos:

x
~
(1)
[
= x1(1) , x (1)
2 , , x i(1) ]x ~
( 2)
[
= x1(2) , x (1)
2 , , x i(2) ,. ]
m = [m 0 , m1 , ]
Sendo ~ , teremos:
M
(1)
x i(1) = ∑ g (1)
l mi -l = g *m i = 0, 1, 2,
l=0 ~ ~

M
( 2)
x i(2) = ∑ g (2)
l m i -l = g *m i = 0, 1, 2,
l=0 ~ ~

Após a convolução as duas sequências são combinadas pelo multiplexador de saída

dando:

~
[
x = x (1) (2) (1) (2) (1) (2)
0 x 0 , x1 x 1 , x 2 x 2 , ]

212
sequência esta que é transmitida através do canal de comunicação.
Exemplo: Na figura 10.9, se a sequência de entrada por (m0 m1 m2 m3 m4) = (10011),
(1 ) (2 )
determine x , x e x .
~ ~ ~

x (1) = g (1) * m
~ ~ ~

x ( 2) = g ( 2) * m
~ ~ ~

x = [11, 10, 11, 1101, 01, 11]

~

10.4.3 (2) Método do domínio da frequência

O processo de codificação segundo os códigos convolucionais é uma filtragem

linear cujo filtro tem resposta finita ao impulso (Finite Impulse Response: FIR).

A convolução da entrada com a resposta impulsional é uma multiplicação no

domínio da frequência para os filtros lineares e invariantes ao deslocamento, o que é o caso
dos codificadores convolucionais (domínio é o campo dos binários 0 e 1).

Definam-se os polinômios geradores como sendo:

g (1) (D) = g (1) (1) (1) 2 (1) M

0 + g1 D + g 2 D + L + g M D

g (2) (D) = g (2) (2) (2) 2 (2) M

0 + g1 D + g 2 D + L + g M D

onde g i(1) e g i(2) i = 0, L, M foram definidos anteriormente, como as amostras da

resposta impulsional do filtro.

213
 A variável Di tem o mesmo significado que o atraso Z-i na representação dos filtros
digitais.

O coeficiente gi de Di, como nos filtros digitais, pode ser escrito diretamente da
estrutura do filtro (codificador convolucional) sendo gi = 0 se não existe conexão do atraso
(shift-register) e ao somador módulo-2 e gi = 1, se existir tal conexão.

Defina-se o polinômio da mensagem como sendo

m(D) = m0 + m1D + m2D2 + … mkDk.

Dessa forma, podemos escrever que

x (1) (D) = g (1) (D) . m(D)

x (1) (D) = g (2) (D) . m(D)

e daí podemos saber os coeficientes de x (1) e x ( 2) e x .

~ ~ ~

Exemplo 8 (pág. 398)

No codificador da figura 8.10(a), entra a mensagem m = [1 0 0 11] , determine

~

x (1) , x ( 2) e x .
~ ~ ~

Então:

m(D) = 1 + D3 + D4

g (1) = [111] → g (1) (D) = 1 + D + D 2

~

214
 g (2) = [1 0 1] → g (2) (D) = 1 + D 2
~

x (1) (D) = (1 + D3 + D 4 ) (1 + D + D 2 ) = 1 + D + D 2 + D3 + D 6

x (2) (D) = (1 + D3 + D 4 ) (1 + D 2 ) = 1 + D 2 + D3 + D 4 + D5 + D 6

Logo

x (1) = [1111 0 0 1] x (2) = [1 0 11111]

~ ~

x = [11, 10, 11, 11, 01, 01, 11]

~

10.4.4 Arvore de código (code tree)

A árvore de códigos é feita supondo-se que a cada instante entra o dígito 0
(convencionado como sendo os ramos para cima ou superiores) ou entra o dígito 1
(convencionado como sendo os ramos para baixo ou inferiores). Para o codificador da
figura 10.9, obtem-se a seguinte árvore de códigos:

215
 ■ A árvore de códigos é feita supondo-se
que a cada instante ou entra o dígito 0
(convencionado como representando a
escolha dos ramos para cima ou
superiores) ou entra o dígito 1
(convencionado como representando a
escolha dos ramos para baixo ou
inferiores). Para o codificador da figura
8.10(a), obtém-se a árvore de códigod ao
lado. Exemplo: Exemplo: Se a entrada
for m = [1 0 0 1 1], a saída, de acordo com

a árvore será: x = [11, 10, 11, 11 01] .

~

■ Verifica-se que a árvore é repetitiva

após o terceiro ramo. Isso porque o filtro
da figura 9 tem três amostras como
resposta impulsional. Após o terceiro
ramo, denota-se os nós de a, b, c e d. Esses
nós são os possíveis estados do processo
aleatório que será desenvolvido pela
possível entrada aleatória.

Figura 10.11 Árvore de códigos para o codificador da figura 10.9.

216
10.4.5 Treliça (trellis)

Do diagrama anterior (árvore de

códigos), é possível obter-se outra forma mais compacta de representar a árvore, em
função dos possíveis estados do sistema. Para o codificador da figura 10.9, a treliça fica
conforme figura a seguir, onde a linha sólida representa a entrada do dígito 0; e uma linha
pontilhada representa a entrada do dígito 1.

Figura 10.12 – Treliça para o código convolucional da figura 10.9

o Dessa treliça, vê-se que se a entrada (mensagem) for a sequência 1 0 0 1 1, a sequência

de saída será: (11, 10, 11, 11, 01), o que concorda com os resultados anteriores.

o A treliça é mais instrutiva do que a árvore, porque traz explicitamente o fato de que o
codificador convolucional é uma máquina de estado finito. Define-se estado do
codificador como sendo os mais recentes (k-1) bits de mensagem movidos para dentro
dos “shift registers”.

217
 A porção da treliça entre j e j + 1 (j ≥ 2) é mostrada na figura 10.13

00
a a
11
11

b
b
00

10
c c

01 01
10
d d

Figura 10.13 Porção da treliça da Figura 10.12

Tabela 10.3 – Estados do codificador da figura 10.12

Estado Descrição Binária
a 00
b 10
c 01
d 11

218
10.4.5 Decodificação por Máxima Probabilidade (Máxima Verossimilhança) dos Códigos
Con6olucionais

A mensagem m entra no codificador e produz o vetor x de saída. Transmite-se

~ ~

x e o receptor recebe y (que deve ser bem parecido com x, a menos dos erros
~ ~ ~

introduzidos no canal de comunicações pelo ruído).

Dado y , o receptor tem que fazer uma estimativa de m , o qual é simbolizada por
~ ~

m̂ .
~

Essa estimativa é feita pela função de máxima probabilidade, ou melhor, o

logaritmo dessa função. Dentre todas, a que for máxima, será a escolhida.

Suponha agora, um canal simétrico e binário.

1-p
0 0

1 1
1-p

Figura 10.14 Representação de um canal simétrico binário

219
Para 1 bit:

p se y i ≠ x i
p( y i /x i ) = 
1 - p se y i = x i (10.35)

Para N bits, a função de probabilidade será:

  N
p y / x  = ∏ p( yi /x i )
 ~ ~  i =1 (10.36)

Então:

    N
log e p y / x  = ln p y / x  = = ∑ ln p( y i /x i )
 ~c ~  ~ ~ i =1 (10.37)

Suponha que o código yex estão em desacordo em d posições (funções

~ ~

incorretas) e tenha N-d corretas. d é chamado de distância de Hamming.

Logo:

 
ln p y / x  = d ln p + ( N - d ) ln(1 - p )
~ ~

 p 
= d ln  + N ln(1 - p)
1- p  (10.38)

 p 
A máxima probabilidade será dada quando d ln  for máxima, que
1 - p 
praticamente só depende de d.

220
 Regra para decodificação de um código convolucional num canal simétrico binário:

“Escolha a estimativa de x̂ que minimiza a distância de Hamming”.

1  p  1
Pois p é em geral bem menor que , logo máx d ln com p <<
2  1 - p  2
será: min[d].

10.4.7 Algoritmo de Viterbi - hard decision

A equivalência entre a máxima probabilidade e a decodificação de mínima

distância para um canal BSC (canal simétrico binário) implica que devemos decodificar o
código convolucional, escolhendo o caminho na árvore de códigos que difere da sequência
recebida no menor número de posições. Com a árvore de códigos é equivalente à treliça,
podemos fazer o mesmo pelos caminhos da treliça que produzem a menor distância de
Hamming.

Isto é exatamente o que o algoritmo de Viterbi faz.

Algoritmo:

Passo 1: Começando no nível j = M compute a métrica (distância para o caminho único na

entrada do codificador. Armazene o caminho (sobrevivente) e sua métrica para cada
estudo.

Passo 2: Incrementando j de 1, compute a métrica para todos os caminhos entrando em

cada estado, somando a métrica dos braços entrantes com a métrica dos sobreviventes dos
tempos anteriores. Para cada estado, identifique o caminho com a menor métrica, como o
sobrevivente do passo 2. Armazene o sobrevivente e sua métrica.

221
Passo 3: Sej j < L + M volte ao passo 2 ou pare.

Exemplo 10.5 Suponha que a sequência recebida seja 0 1 0 0 0 1 0 0 0 0 ... e a sequência

enviada tenha sido 0 0 0 0 ... 0 0 0 0.

Ou seja, existem dois erros na sequência recebida, devido a ruído no canal. Este
erro duplo é corrigido com o algoritmo de Viterbi, onde o codificador é o da figura 10.9

Figura 10.15 – Decodificação de Viterbi do exemplo 10.5

Então, decodificando como: 0, 0, 0, 0, 0.

222
Exemplo 10.6 Envia-se 0 0 0 0 ... 0 (tudo zero) e recebe-se (1 1 0 0 0 1 0 0 0 0 ...), ou
seja, temos 3 erros.
Usando-se o algoritmo de Viterbi (para o codificador da figura 9) obtém-se:

Figura 10.16 – Decodificação de Viterbi do exemplo 10.6

O algoritmo falha na decodificação da sequência recebida contendo 3 erros.

223
224
225
Apêndice B

226
227
228
229
230
231
232
233
234
235