Trabalho de Conclusão de Curso - Fernando Sacilotto Crivellaro

UNIVERSIDADE FEDERAL DO RIO GRANDE DO SUL
ESCOLA DE ENGENHARIA
DEPARTAMENTO DE ENGENHARIA ELÉTRICA
Fernando Sacilotto Crivellaro
Implementação de Código Reed-Solomon para Correção de Erros
Porto Alegre
2012

Trabalho de Conclusão de Curso apresentado ao
Departamento de Engenharia Elétrica da Uni-
versidade Federal do Rio Grande do Sul, como
requisito parcial à obtenção do título de Bacharel
em Engenharia Elétrica.
Orientador: Prof. Dr. Marcelo Götz
Porto Alegre
2012

Este Trabalho de Conclusão de Curso foi analisado
e julgado adequado para a obtenção do título de ba-
charel em Engenharia Elétrica pela Universidade Fe-
deral do Rio Grande do Sul e aprovado em sua forma
ﬁnal pelo Orientador e pela Banca Examinadora.
Orientador: Prof. Dr. Marcelo Götz, UFRGS
Doutor pela Universität Paderborn - Paderborn, Alemanha
Data
Banca Examinadora:
Prof. Dr. Marcelo Götz, UFRGS
Doutor pela Universität Paderborn - Paderborn, Alemanha
Prof. Dr. Gilson Inácio Wirth, UFRGS
Doutor pela Universität Dortmund - Dortmund, Alemanha
Eng. Luca Bochi Saldanha, Digitel S/A Indústria Eletrônica
Engenheiro pela Universidade Federal do Rio Grande do Sul

RESUMO
O presente relatório refere-se ao trabalho realizado durante a disciplina Projeto de Diplomação,
do curso de Engenharia Elétrica da Universidade Federal do Rio Grande do Sul. A sua aborda-
gem está relacionada ao controle de erros em um canal sem memória, através de redundância
estruturada, utilizando linguagem de descrição de hardware. A codificação linear em blocos,
não binária e cíclica, escolhida para o desempenho desta tarefa é do tipo Reed-Solomon, uma
importante subclasse dos códigos Bose-Chaudhuri e Hocquenghem. Após um breve histórico
sobre codificação de canal e um estudo matemático necessário para o entendimento dos algorit-
mos, apresenta-se os tipos de código que definem a estrutura básica do próprio Reed-Solomon.
Enfim, com o desenvolvimento do codificador e decodificador RS(255, 239), os resultados ob-
tidos através de simulações são mostrados, os quais ilustram a atuação deste tipo de código na
correção de erros e os recursos necessários para a sua implementação em hardware programável.
Palavras-chave: Linguagem de descrição de hardware. Reed-Solomon. Hardware programável.

ABSTRACT
The present report refers to the work performed along the Graduation Project discipline of the
Electrical Engineering course from Universidade Federal do Rio Grande do Sul. The approach
is related to error control in a channel without memory through structured redundancy, using
hardware description language. The choosen linear block, non-binary and cyclic codification to
do this is the Reed-Solomon, one important Bose-Chaudhuri and Hocquenghem codes subclass.
After a brief history about channel codification and a necessary mathematic study to understand
the algorithms, is presented the code types that define the own Reed-Solomon basic structure.
At the end, with the RS(255, 239) encoder and decoder development, simulation results that
illustrate the code performance in error correction and the resources to implementation in pro-
grammable hardware are presented.
Keywords: Hardware Description Language. Reed-Solomon. Programmable Hardware.

LISTA DE FIGURAS
Figura 1 – Sistema de comunicação digital simplificado . . . . . . . . . . . . . . . 13
Figura 2 – LFSR de tamanho L . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Figura 3 – Célula Multiplicadora . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Figura 4 – Conjunto de Células para multiplicação dos polinômios a(X) e b(X) . . 49
Figura 5 – Simulação de uma operação do conjunto de células . . . . . . . . . . . 49
Figura 6 – Codificador RS(255, 239) . . . . . . . . . . . . . . . . . . . . . . . . . 50
Figura 7 – Codificação de dados gerados pseudo-aleatoriamente: início . . . . . . . 51
Figura 8 – Codificação de dados gerados pseudo-aleatoriamente: fim . . . . . . . . 51
Figura 9 – Decodificador RS em blocos . . . . . . . . . . . . . . . . . . . . . . . 51
Figura 10 – Unidade de cálculo de síndrome . . . . . . . . . . . . . . . . . . . . . . 52
Figura 11 – Bloco de cálculo de síndrome RS(255, 239) . . . . . . . . . . . . . . . 53
Figura 12 – Simulação do bloco de síndrome, S(X) = 0 . . . . . . . . . . . . . . . . 53
Figura 13 – Simulação do bloco de síndrome, S(X) = 0 . . . . . . . . . . . . . . . . 54
Figura 14 – Diagrama de blocos do algoritmo de Berlekamp-Massey . . . . . . . . . 55
Figura 15 – Deslocamento do polinômio de síndromes para dentro do registrador S . 56
Figura 16 – Evolução do polinômio de conexão ao longo das 16 iterações . . . . . . 56
Figura 17 – Aplicação da equação chave . . . . . . . . . . . . . . . . . . . . . . . . 57
Figura 18 – Saídas do bloco de Berlekamp-Massey . . . . . . . . . . . . . . . . . . 57
Figura 19 – Diagrama de blocos do algoritmo de Chien para σσσ(X) . . . . . . . . . . 58
Figura 20 – Simulação do bloco Chien Localizador para o RS(255, 239) . . . . . . . 59
Figura 21 – Diagrama de blocos do algoritmo de Chien para ΩΩΩ(X) . . . . . . . . . . 59
Figura 22 – Simulação do bloco Chien Avaliador para o RS(255, 239) . . . . . . . . 60
Figura 23 – Diagrama de blocos do algoritmo de Forney . . . . . . . . . . . . . . . 60
Figura 24 – Simulação do bloco de Forney do RS(255, 239) . . . . . . . . . . . . . 60
Figura 25 – Sistema para simulação do RS(255, 239) . . . . . . . . . . . . . . . . . 61
Figura 26 – Visão geral da simulação do RS(255, 239) . . . . . . . . . . . . . . . . 61
Figura 27 – Saída codificada do encoder RS(255, 239) . . . . . . . . . . . . . . . . 62
Figura 28 – Entrada corrompida com erros contínuos, decodificador RS(255, 239) . 62
Figura 29 – Saída decodificada do RS(255, 239), erros contínuos corrigidos . . . . . 62
Figura 30 – Erros nos símbolos de paridade, decodificador RS(255, 239) . . . . . . 63
Figura 31 – Correção de erros nos símbolos de paridade, decodificador RS(255, 239) 63
Figura 32 – Simulação do RS(255, 239) para erros peudo-aleatórios . . . . . . . . . 64

LISTA DE TABELAS
Tabela 1 – Adição em módulo-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Tabela 2 – Multiplicação em módulo-2 . . . . . . . . . . . . . . . . . . . . . . . . 16
Tabela 3 – Alguns polinômios primitivos . . . . . . . . . . . . . . . . . . . . . . . 17
Tabela 4 – Possíveis representações de campos finitos . . . . . . . . . . . . . . . . 20
Tabela 5 – Adição sobre GF(23) com f(X) = 1+X +X3 . . . . . . . . . . . . . . . 20
Tabela 6 – Multiplicação sobre GF(23) com f(X) = 1+X +X3 . . . . . . . . . . . 21
Tabela 7 – Relação entre palavras de código e mensagens para um código (6,3) . . . 23
Tabela 8 – Resultado da sintetização do codificador RS(255, 239) . . . . . . . . . . 65
Tabela 9 – Resultado da sintetização do decodificador RS(255, 239) . . . . . . . . 65

LISTA DE ABREVIATURAS
A/D Analógico para Digital
BCH Bose, Chaudhuri e Hocquenghem
BSC Binary Symmetric Channel
D/A Digital para Analógico
FEC Forward Error Correction
FPGA Field-Programmable Gate Array
GF Galois Field
JSIAM Journal of the Society for Industrial and Applied Mathematics
LFSR Linear Feedback Shift Register
LSB Least Signiﬁcant Bit
MMC Mínimo Múltiplo Comum
MSB Most Signiﬁcant Bit
OTN Optical Transport Network
RS Reed-Solomon
VHDL VHSIC Description Language
VHSIC Very High Speed Integrated Circuits

SUMÁRIO
1 INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.1 MOTIVAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 OBJETIVOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 ESTRUTURA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2 CODIFICAÇÃO DE CANAL . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1 SISTEMA DE COMUNICAÇÃO SIMPLIFICADO . . . . . . . . . . . . . . . 13
2.2 FORMAS DE CONTROLE DE ERROS . . . . . . . . . . . . . . . . . . . . . 14
2.3 BREVE HISTÓRICO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3 CAMPOS FINITOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.1 DEFINIÇÕES BÁSICAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2 CONSTRUÇÃO DO CAMPO . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2.1 Polinômios Primitivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.3 OPERAÇÕES EM CAMPOS ESTENDIDOS . . . . . . . . . . . . . . . . . . . 18
3.4 PROPRIEDADES BÁSICAS DOS CAMPOS DE GALOIS . . . . . . . . . . . 21
4 CÓDIGOS LINEARES EM BLOCO . . . . . . . . . . . . . . . . . . . . . . 23
4.1 ASPECTOS ESTRUTURAIS . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.1.1 Linearidade e Matriz Geradora . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.1.2 Códigos Sistemáticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.1.3 Matriz de Verificação de Paridade . . . . . . . . . . . . . . . . . . . . . . . . 25
4.1.4 Síndrome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.1.5 Distância Mínima de um Código em Bloco . . . . . . . . . . . . . . . . . . . 27
4.1.6 Arranjo Padrão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
5 CÓDIGOS CÍCLICOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.1 ESTRUTURA ALGÉBRICA . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.1.1 Polinômio Gerador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.1.2 Codificação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.1.3 Matrizes Geradora e de Verificação de Paridade . . . . . . . . . . . . . . . . 32
5.1.4 Síndrome de Códigos Cíclicos . . . . . . . . . . . . . . . . . . . . . . . . . . 33
6 CÓDIGOS BCH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
6.1 ESTRUTURA ALGÉBRICA . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
6.1.1 Polinômio Gerador e Codificação . . . . . . . . . . . . . . . . . . . . . . . . 35
6.1.2 Matriz de Verificação de Paridade . . . . . . . . . . . . . . . . . . . . . . . . 36

9
6.2 DECODIFICAÇÃO DE CÓDIGOS BCH . . . . . . . . . . . . . . . . . . . . . 37
7 CÓDIGOS REED-SOLOMON . . . . . . . . . . . . . . . . . . . . . . . . . 39
7.1 CÓDIGOS LINEARES EM BLOCO CÍCLICOS NÃO BINÁRIOS . . . . . . . 39
7.2 DEFINIÇÃO ALGÉBRICA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
7.2.1 Polinômio Gerador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
7.3 CODIFICAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
7.4 DECODIFICAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
8 ARQUITETURA DESENVOLVIDA . . . . . . . . . . . . . . . . . . . . . . 47
8.1 CÉLULA MULTIPLICADORA . . . . . . . . . . . . . . . . . . . . . . . . . . 47
8.2 CODIFICADOR RS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
8.3 DECODIFICADOR RS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.3.1 Cálculo da Síndrome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.3.2 Berlekamp-Massey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.3.3 Chien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
8.3.4 Forney . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
9 RESULTADOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.1 SIMULAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.1.1 Erros Contínuos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
9.1.2 Erros nos Símbolos de Paridade . . . . . . . . . . . . . . . . . . . . . . . . . 63
9.1.3 Erros Pseudo-Aleatórios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
9.2 SINTETIZAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9.2.1 Codiﬁcador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9.2.2 Decodiﬁcador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
10 CONCLUSÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
10.1 TRABALHOS FUTUROS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
REFERÊNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
ANEXO A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

10
1 INTRODUÇÃO
O volume de dados produzidos pela população está sempre em crescimento, com isso gera-
se um fluxo de informação cada vez mais denso e geralmente sob exigências de grandes velo-
cidades, portanto, altas taxas de dados. Com a globalização mais dinâmica do que nunca, as
distâncias entre os enlaces de comunicação se tornam maiores, exigindo, consequentemente, o
avanço tecnológico do sistema de comunicação inteiro para atender a demanda.
No entanto, a base de qualquer tecnologia desenvolvida é a teoria que a fundamenta. Devido
à complexidade de um sistema de comunicação, no caso digital, este trabalho possui seu foco
imposto sobre apenas uma parte do mesmo, a relacionada com codificação de canal. Busca-se,
então, o aprofundamento teórico necessário para realizar na prática o controle de erros em uma
transmissão de dados, aumentando a sua robustez.
Um tipo de sistema de comunicação com capacidade para atender os requisitos da demanda
de dados atuais é o que utiliza fibras ópticas. Assim, especificou-se mais ainda o assunto do
trabalho à operação neste sistema, de acordo com a recomendação G.709/Y.1331, criada pela
International Telecommunication Union (ITU), que trata de aspectos relacionados à transmis-
sões digitais com altas taxas de dados em redes de transporte óptico, ou Optical Transport
Network (OTN). Em relação à codificação de canal, esta recomendação especifica a utilização
do código RS(255, 239) para o controle de erros, como mostrado no ANEXO A. Portanto,
optou-se pelo estudo e desenvolvimento deste código no trabalho.
Em relação à linguagem, os códigos RS podem ser desenvolvidos em diversas delas. No
entanto, a aplicação em que o código será utilizado direciona a implementação para alguma
linguagem mais apropriada. Por exemplo, para a transmissão de dados em altas taxas, a lingua-
gem de descrição de hardware, VHDL, é bastante apropriada, pois permite descrever operações
rápidas em nível de circuitos eletrônicos como portas lógicas e paralelamente. Da prática, sabe-
se que um sistema operando em redes de transporte óptico utiliza uma frequência próxima a
200 MHz. Assim, o código RS(255, 239) será desenvolvido através da linguagem VHDL.
1.1 MOTIVAÇÃO
A ideia deste trabalho motiva-se pela busca de aprimoramento teórico nas concepções ma-
temáticas relacionadas aos códigos algébricos e algoritmos para detecção e correção de erros.
Tal intenção ocorre conjuntamente com a de projeto prático, proveniente da necessidade de tais
conhecimentos para o desenvolvimento de produtos durante período de estágio em empresas da
área.
Complementa-se as razões comentadas, a crescente elevação das taxas de transmissão de
dados, requerendo tratamentos de erros cada vez mais sofisticados e complexos. Entre eles,
nota-se a utilização do RS em conjunto com outros códigos, como os convolucionais, aumen-
tando consideravelmente a capacidade de controle de erros.

11
Do ponto de vista empresarial, a motivação acontece a partir da importância do domínio
da tecnologia que começa a ser ressaltada na medida em que ocorre a necessidade deste co-
nhecimento para o desenvolvimento de produtos, afetando inclusive o balanço econômico entre
manter a longo prazo uma licença de uso e o investimento em uma parceria público-privada
com a universidade, por exemplo, de forma que beneficie ambas.
1.2 OBJETIVOS
Este trabalho possui um objetivo principal, a fim de nortear os demais. Então, acima
de tudo, busca-se desenvolver, através de linguagem de descrição de hardware, a codificação
RS(255, 239) especificada pela recomendação ITU-T G.709/Y.1331 (2009).
Consequentemente, procura-se expôr o aprofundamento dos conceitos matemáticos envol-
vidos e ainda, as estruturas dos códigos que permitiram o surgimento do Reed-Solomon. Com
isso, ocorre também a intenção de estimular, dentro da universidade, discussões a respeito da
teoria relacionada à codificação de canal, ressaltando a sua importância.
Por fim, deseja-se traduzir para a linguagem VHDL as operações desenvolvidas pelos al-
goritmos matemáticos utilizados neste código, exibindo a complexidade dessa relação teórico-
prática, mesmo para algumas operações matemáticas aparentemente simples, como a multipli-
cação ou até cálculo das raízes de polinômios.
1.3 ESTRUTURA
O desenvolvimento do trabalho foi estruturado de maneira a permitir o avanço gradual no
entendimento de seu conteúdo, pois, a cada passo na direção dos códigos Reed-Solomon (que
são lineares em bloco, cíclicos e não binários), ocorre a necessidade de familiarização com a
teoria que o precede.
No Capítulo 2, realiza-se uma contextualização da codificação de canal dentro de um sis-
tema de comunicação genérico, apresentando uma ideia básica do que o compõe. Também são
abordadas duas maneiras de se realizar controle de erros, discernindo qual delas é a utilizada
neste trabalho. Posteriormente, há uma visão histórica a respeito da teoria de codificação de
canal, com o intuito de se obter uma ideia do que já foi desenvolvido e quando. Além disso,
é possível perceber que o surgimento dos códigos e suas diferentes características avançam
de acordo com o desenvolvimento teórico da época, então, torna-se interessante conhecer um
pouco da história para prever o conteúdo que deve ser estudado, a fim de alcançar os objetivos
traçados.
Inicia-se no Capítulo 3 a teoria. O primeiro assunto desenvolvido está relacionado aos
campos finitos, ou de Galois. Este assunto serve de base para todos os códigos apresentados ao
longo deste trabalho, principalmente para o RS.

12
Prosseguindo ao Capítulo 4, os códigos lineares em bloco formam o primeiro tipo de código
tratado, pois sobre suas definições e estruturas genéricas, se apoiam os restantes. Mas, por não
ser eficiente a sua decodificação na prática para a época, surgem os códigos cíclicos, comentados
no Capítulo 5. Estes, apresentam, além das características explicitadas no tipo anterior, aspectos
instrínsecos que permitem uma maior praticidade na sua operação.
Ainda antes do código RS, aborda-se no Capítulo 6 os códigos de Bose, Chaudhuri e Hoc-
quenghem. Estes, mais eficientes que os códigos anteriores, possuem diversos métodos para
decodificá-los, permitindo então sua disceminação prática.
Classificado como uma subclasse dos códigos BCH não binários, enfim chega-se ao RS no
Capítulo 7. Sua estrutura é semelhante ao tipo comentado anteriormente, diferindo apenas em
detalhes. Aborda-se teoricamente o método de decodificação de Berlekamp-Massey, o qual foi
utilizado no desenvolvimento prático, como será visto adiante. Além disso, finaliza-se neste
ponto o tratamento teórico deste trabalho.
Assim, dá-se início às descrições das arquiteturas dos blocos que compõe o RS(255, 239)
no Capítulo 8. São apresentadas figuras e trechos de simulações para expressarem as tarefas
desenvolvidas tanto pelo codificador quanto pelo decodificador. Estes, descritos através de
linguagem de descrição de hardware, ou VHDL.
Dedica-se ainda o Capítulo 9 para exibição dos resultados obtidos nas simulações. A ideia
é mostrar os pontos importantes e de maior interesse para uma aplicação prática, inclusive
fornecendo informações do uso de hardware e frequência máxima de operação.
Enfim, no Capítulo 10 conclui-se a respeito dos desafios encontrados ao longo do desen-
volvimento do trabalho, dos resultados atingidos e de possíveis melhorias ou continuidades de
estudo.

13
2 CODIFICAÇÃO DE CANAL
O código RS é considerado um tipo de codificação de canal. Ou seja, sua ação está relacio-
nada ao controle de erros que podem ocorrer ao longo de um canal de comunicação. Assim, para
iniciar o desenvolvimento do trabalho, apresenta-se a seguir uma ideia básica de um sistema de
comunicação.
2.1 SISTEMA DE COMUNICAÇÃO SIMPLIFICADO
Um sistema de comunicação digital é composto por diversos componentes e cada um deles
pode ser tratado separadamente visando clareza no entendimento de suas funções. Através da
Figura 1 é possível identificar em vermelho, dentro desse sistema simplificado, a localização
dos blocos de codificação e decodificação de canal, os quais são o foco do presente trabalho:
Figura 1 – Sistema de comunicação digital simplificado
A fonte de informação pode ser a fala de uma pessoa ou dados de um computador, por
exemplo. A informação gerada pela fonte é encaminhada para o codificador da fonte, o qual
e responsável pela adaptação da informação ao tipo de sistema, podendo ser um transdutor em
conjunto com um conversor A/D, ou um algum tipo de compressão de dados digitais, de forma
que o número de bits representantes da informação por unidade de tempo seja, idealmente,
o menor possível, e a saída não seja ambígua. Ou seja, o codificador da fonte transforma a
informação gerada em dígitos binários, formando uma sequência de símbolos, denotada, por
exemplo, por u.
Prosseguindo no esquema acima, o codificador de canal recebe a sequência de informação
u e gera, a partir dela, uma sequência codificada v denominada palavra código. Esta, possui
mais símbolos do que a sequência de informação e esses símbolos adicionais são utilizados
para recuperação da mensagem, caso ela seja corrompida ao longo do canal.

14
Adiante, sendo o canal um meio físico, torna-se necessária a operação do modulador para
transformar o sinal discreto, proveniente do codificador de canal, em formas de onda analógicas
voltadas para a transmissão.
O canal é o meio pelo qual o sistema de comunicação interliga o transmissor e o receptor,
podendo ser de diveros tipos, como por exemplo, o ar, cabos coaxias, as fibras óticas e outros.
As ondas emitidas pelo transmissor podem ser corrompidas de diversas formas ao longo do seu
percurso pelo canal, resultando em diferentes tipos de erros, como por exemplo, contínuos ou
não.
O destino do sinal ao fim do canal é o receptor, mais precisamente o bloco de demodulação,
que processa cada forma de onda recebida e fornece em sua saída um sinal discreto ou contí-
nuo, dependendo dos blocos posteriores, chamado de sequência recebida r. Essa sequência é
então repassada para o bloco de decodificação do canal, o qual através de algoritmos especí-
ficos, baseados na codificação do canal, é capaz de corrigir uma quantidade limitada de erros,
fornecendo em sua saída uma estimativa da sequência de símbolos transmitida, û.
Por fim, a partir de û o decodificador da fonte fornece em sua saída a estimativa da infor-
mação, sendo em alguns casos necessária uma conversão D/A, por exemplo.
2.2 FORMAS DE CONTROLE DE ERROS
Duas maneiras distintas de controle de erros, utilizando redundância, podem ser utilizadas.
Uma delas é a detecção de erros e retransmissão, que utiliza símbolos de paridade (símbolos
redundantes adicionados aos dados) para detectar a ocorrência de algum erro. O terminal re-
ceptor, então, não corrige os erros, apenas os detecta e realiza o pedido de uma retransmissão
dos dados.
Outra forma de controle de erros é a chamada Forward Error Correction (FEC), a qual
utiliza os símbolos de paridade tanto para a detecção, quanto para correção dos erros. Não
são todos os padrões de erros que podem ser corrigidos, como será visto posteriormente, e
os códigos corretores de erros são classificados de acordo com suas capacidades de correção
(SKLAR, 2001).
A maior vantagem do decodificador que utiliza retransmissão, em relação à correção ante-
cipada de erros, é a simplicidade de implementação requerida. Além disso, a primeira forma é
adaptativa, no sentido de que a informação somente será retransmitida quando ocorrerem erros.
Por outro lado, há situações em que a FEC é necessária como, por exemplo, quando um canal
reverso não é disponibilizado, quando o atraso devido à retransmissão é excessivo, ou o número
de erros é demasiado, necessitando de muitas retransmissões. Como exemplo de sistemas que
utilizam FEC, pode ser citado o armazenamento digital, no qual a informação gravada pode
ser reproduzida semanas ou até meses depois. A maioria dos sistemas codificados atualmente
emprega alguma forma de FEC (LIN; COSTELLO, 2004).

15
2.3 BREVE HISTÓRICO
Em 1948, Claude Shannon demonstrou que há, associado com qualquer canal de comuni-
cação ou de armazenamento, um número C (medido em bits por segundo) chamado de capa-
cidade do canal. Isso significa que, sendo a taxa de transmissão de informação requerida por
um sistema de comunicação ou armazenamento menor do que C, é possível desenvolver uma
codificação do canal que permite uma probabilidade de erro de saída tão pequena quanto dese-
jada. No entanto, Shannon não demonstrou como encontrar tais códigos, sua contribuição foi
apenas provar que eles existem e definir suas funções (BLAHUT, 2003). Mas essa afirmação
foi suficiente para chamar a atenção, na época, para o desenvolvimento mais intenso da teoria
de codificação.
A teoria dos códigos Reed-Solomon está intimamente ligada à história da codificação em
blocos e, mais particularmente, algébrica. Com a introdução de estruturas matemáticas cres-
centemente complexas, diversas classes de codificação em blocos surgiram, juntamente com
significados algébricos de decodificação. No início da década de 50, Richard Hamming já ha-
via produzido o primeiro código binário de uso prático, utilizando técnicas de álgebra linear, e
definindo a classe dos códigos de correção em blocos com capacidade de corrigir um erro. Na
mesma época, Marcel Golay desenvolveu o código de correção trípla de erros. Em 1954, David
Muller inventou uma classe de códigos de correção múltipla de erros, na qual Irving Reed reco-
nheceu uma estrutura algébrica específica, resultando em um algoritmo de decodificação para
a mesma, que tornou-se atualmente a classe de códigos Reed-Muller. Com o trabalho de Neal
Zierler, Solomon Golomb e Eugene Prange, estes códigos foram logo gerados por registradores
de deslocamento linear, ou LFSR, com paridade adicionada, dotando-os de estrutura cíclica.
No final da década de 50, Reed estava fortemente interessado na teoria de Galois, refletindo
sobre a utilização de símbolos não binários de campos finitos em operações no nível de bytes,
em oposição ao foco tradicional de algoritmos orientados a bits. Nesta época, Reed também
estava introduzindo Gustave Solomon, especialista em álgebra, ao mundo da teoria de codifica-
ção, e tal parceria foi responsável pelo descobrimento de uma nova classe de códigos, utilizando
uma definição algébrica que introduziu somas simétricas como síndromes para um algoritmo
de decodificação (WICKER; BHARGAVA, 1994).
Assim, em 1960, ocorreu a primeira aparição pública dos códigos Reed-Solomon, ou tam-
bém RS, no artigo intitulado Polynomial Codes over Certain Finite Fields, publicado no Journal
of the Society for Industrial and Applied Mathematics, JSIAM. Nas décadas posteriores ao seu
descobrimento, os códigos RS já estavam presentes em diversas aplicações, desde aparelhos de
Compact Disc até veículos espaciais.
Atualmente, a importância e a utilização deste tipo de código ainda prevalece, como no caso
de sistemas ópticos e também devido à atuação em conjunto com outros códigos, visando maior
poder de correção e controle de erros. São os chamado códigos concatenados.

16
3 CAMPOS FINITOS
A teoria de campos finitos, ou de Galois é fundamental para os códigos não binários Reed-
Solomon. Todas as operações desenvolvidas, tanto na codificação quanto na decodificação,
utilizam-na. Dessa maneira, a própria mensagem transmitida é considerada como formada por
elementos do campo em que se está trabalhando.
Então, este capítulo dedica-se à abordagem teórica de campos finitos, ou de Galois, servindo
como base para o restante da teoria e prática deste trabalho.
3.1 DEFINIÇÕES BÁSICAS
Um campo é o conjunto de elementos no qual é possível realizar operações de adição, sub-
tração, multiplicação e divisão sem deixar o conjunto. As operações de adição e multiplicação
devem satisfazer as leis comutativa (a · b = b · a), associativa [(a + b) + c = a + (b + c)] e dis-
tributiva (a·(b+c) = a·b+a·c) (LIN; COSTELLO, 2004). Como exemplo, cita-se o campo
binário denotado por GF(2) que realiza as seguintes operações:
Tabela 1 – Adição em módulo-2
+ 0 1
0 0 1
1 1 0
Tabela 2 – Multiplicação em módulo-2
· 0 1
0 0 0
1 0 1
O número de elementos pertencentes ao conjunto é chamado de ordem, e um campo com
número finito de membros denomina-se campo finito (ou de Galois). Por exemplo, um campo
finito constituído por q elementos é indicado por GF(q), sendo q um número primo. É possível
estender GF(q) para um campo de q = pm elementos, chamando-o de campo estendido de
GF(q) e denotando-o por GF(pm), neste caso, p é primo e m é inteiro positivo não nulo. Nos
códigos de controle de erros, o campo estendido GF(2m) é de extrema importância, como será
visto ao longo do texto, e por isso terá mais ênfase em sua abordagem.
3.2 CONSTRUÇÃO DO CAMPO
A composição de GF(2m) é dada por, além de 0 e 1, elementos adicionais únicos represen-
tados a partir do símbolo α e suas potências (SKLAR, 2001).
0,1,α,α2
,··· ,α j
,··· = 0,α0
,α1
,α2
,··· ,α j
,···
α2
= α ·α
α3
= α ·α ·α
...

17
Assim, percebe-se que há uma propriedade importante dos campos de Galois: sempre ha-
verá um elemento, o qual suas potências formam todos os membros não nulos do campo. Tal
componente é denominado elemento primitivo.
Além disso, a definição de campos finitos também recai sobre os campos estendidos, ou
seja, GF(2m) deve ser finito, possuir somente 2m elementos, e ser fechado sobre multiplicação.
Portanto, as potências de α não podem ser todas distintas infinitamente, ou seja, em algum
ponto na sequência deve ocorrer uma repetição.
3.2.1 Polinômios Primitivos
Com o intuito de avançar no entendimento dos campos, torna-se necessária a introdução da
classe de polinômios primitivos, a qual define os campos finitos estendidos GF(2m) de extenso
uso nos códigos RS. Para um polinômio ser enquadrado nesta classe, ele deve ser irredutível.
Entende-se por irredutível o polinômio que não pode ser fatorado em polinômios de ordens
menores.
Segundo SKLAR (2001), um polinômio irredutível, ϕϕϕ(X), de grau m é dito primitivo se o
menor inteiro positivo n, para o qual ϕϕϕ(X) divide Xn + 1, for n = 2m − 1. Embora, teorica-
mente, um polinômio irredutível e não primitivo também possa definir um campo estendido, é
mais conveniente utilizar um polinômio primitivo para essa definição, pois sua raiz é elemento
primitivo do campo. Esses polinômios já estão disponíveis em livros através de tabelas, como a
mostrada a seguir, por isso serão utilizados sem a demonstração de serem primitivos, assumindo
que tal tarefa já foi desempenhada pelas fontes consultadas.
Tabela 3 – Alguns polinômios primitivos
m Polinômio Primitivo m Polinômio Primitivo
3 1+X +X3 9 1+X4 +X9
4 1+X +X4 10 1+X3 +X10
5 1+X2 +X5 11 1+X2 +X11
6 1+X +X6 12 1+X +X4 +X6 +X12
7 1+X3 +X7 13 1+X +X3 +X4 +X13
8 1+X2 +X3 +X4 +X8 14 1+X +X6 +X10+X14
Fonte: SKLAR(2001).
Suponha que ϕϕϕ(X) é um polinômio primitivo de grau m sobre GF(2). Ao considerar α
como raiz de ϕϕϕ(X) e sabendo que, por definição, ϕϕϕ(X) divide X2m−1 +1, tem-se, sendo q(X) o
quociente da divisão:
X2m−1
+1 = q(X)ϕϕϕ(X)
α2m−1
+1 = q(α)ϕϕϕ(α)
α2m−1
+1 = q(α)·0

18
então, utilizando operações em módulo-2, obtém-se:
α2m−1
= 1 = α0
. (3.1)
Utilizando (3.1) é possível delimitar a sequência
S = 0,1,α,α2
,··· ,α2m−2
,α2m−1
,α2m
,···
em
S = 0,α0
,α1
,α2
,··· ,α2m−2
,α0
,α1
(3.2)
e assim, deﬁnir os elementos do campo estendido GF(2m):
GF(2m
) = 0,α0
,α1
,α2
,··· ,α2m−2
(3.3)
Analisando (3.2) e (3.3), conclui-se que o grupo deﬁnido por GF(2m) é cíclico. Além disso,
observa-se que todos os elementos não nulos podem ser representados como potências de um
mesmo α, logo α é o elemento primitivo do campo. Portanto, um campo estendido de Galois
pode ser completamente construído sobre seu elemento primitivo.
A forma de exibição em (3.3) é chamada representação de GF(2m) por potência, outra
representação é a polinomial, em que cada um dos 2m elementos é representado através de
polinômios distintos de grau m−1 ou menos.
Sendo i = 0,1,2,··· ,2m −2, divide-se o polinômio Xi pelo primitivo ϕϕϕ(X):
Xi
= qi(X)ϕϕϕ(X)+ai(X) (3.4)
onde qi(X) é o quociente e ai(X) é o resto (polinômio de grau m−1 ou menor):
ai(X) = ai,0 +ai,1X1
+ai,2X2
+···+ai,m−1Xm−1
(3.5)
Pelo fato de que Xi e ϕϕϕ(X) são primos relativos, isto é, eles não possuem fatores em co-
mum, exceto o número 1, Xi não é divisível por ϕϕϕ(X). Dessa forma, para qualquer i ≥ 0,
ai(X) = 0 (LIN; COSTELLO, 2004). Substituindo X = α em (3.5), se obtém a expressão para
os elementos não nulos:
αi
= ai,0 +ai,1α1
+ai,2α2
+···+ai,m−1αm−1
3.3 OPERAÇÕES EM CAMPOS ESTENDIDOS
Avançando no entendimento dos campos estendidos, é importante a abordagem das opera-
ções aritméticas realizadas entre os seus elementos.
Para o campo binário GF(2), a adição é desenvolvida em módulo-2, ou também OU-

19
exclusivo (XOR). Além disso, a subtração é exatamente igual à adição,
u−v = u+v = u⊕v (3.6)
onde u e v ∈ GF(2).
Qualquer elemento de GF(2m) pode ser representado como um polinômio com seus coe-
ficientes retirados de GF(2) (JIANG, 2010). Assim, adição e subtração são realizadas como
segue,
u(X)+v(X) = (u0 ⊕v0)+(u1 ⊕v1)X +···+(um−1 ⊕vm−1)Xm−1
(3.7)
sendo as operações (ui ⊕vi) realizadas em módulo-2.
No caso da multiplicação de elementos representados na forma de potência, a operação de
multiplicação resume-se à soma dos expoentes de cada componente. No entanto, o resultado é
ajustado para o campo, como observado a seguir:
αa
·αb
= α(a+b)mod(2m−1)
.
Quando a operação de multiplicação é realizada com elementos representados por polinô-
mios, ela assume a forma ordinária, ou comum. No entanto, em módulo sobre o polinômio
primitivo sobre o qual GF(2m) é construído,
w(α) = u(X)v(X)modϕϕϕ(X)|x=α.
Para valores relativamente altos de m, por exemplo m > 3, a construção do campo para fins
de entendimento do mesmo torna-se massante e desnecessária. Em função disso, será utilizado
como exemplificação o campo estendido GF(23) que possui como polinômio primitivo ϕϕϕ(X) =
f(X) = 1+X +X3 e, assumindo que α é raiz de ϕϕϕ(X), a seguinte relação pode ser obtida,
f(α) = 1+α +α3
= 0
α3
= 1+α (3.8)
assim, os demais elementos são derivados de (3.8):
α4
= α ·α3
= α(1+α) = α +α2
α5
= α2
·α3
= α2
(1+α) = α2
+α3
= 1+α +α2
α6
= α3
·α3
= (1+α)(1+α) = 1+α +α +α2
= 1+α2
α7
= α3
·α4
= (1+α)(α +α2
) = α +α2
+α2
+α3
= α +1+α = 1 = α0
...
Com isso, é possível montar uma tabela com três tipos diferentes de representação de um campo,

20
em que no terceiro tipo são utilizadas sequências de bits. A Tabela 4 demonstra essas três
maneiras de visualização.
Tabela 4 – Possíveis representações de campos ﬁnitos
Representação em Potência Representação Polinomial Representação em Sequência
0 0 (000)
α0 1 (100)
α1 X (010)
α2 X2 (001)
α3 1 + X (110)
α4 X + X2 (011)
α5 1 + X + X2 (111)
α6 1 + X2 (101)
α7 1 (100)
A partir de (3.7) e da Tabela 4, exempliﬁca-se as operações aritméticas quando realiza-
das sobre um campo estendido, no caso GF(23). Observam-se pontos importantes nas tabelas
abaixo, como a diagonal principal da Tabela 5 formada por zeros, ou seja, a soma de qualquer
elemento com ele mesmo é nula. E ainda, sendo α0 o elemento identidade da multiplicação, na
Tabela 6, percebe-se que a multiplicação de um elemento pelo seu inverso resulta em α0.
Tabela 5 – Adição sobre GF(23) com f(X) = 1+X +X3
+ α0 α1 α2 α3 α4 α5 α6
α0 0 α3 α6 α1 α5 α4 α2
α1 α3 0 α4 α0 α2 α6 α5
α2 α6 α4 0 α5 α1 α3 α0
α3 α1 α0 α5 0 α6 α2 α4
α4 α5 α2 α1 α6 0 α0 α3
α5 α4 α6 α3 α2 α0 0 α1
α6 α2 α5 α0 α4 α3 α1 0
Fonte: SKLAR, 2001, p. 449.

21
Tabela 6 – Multiplicação sobre GF(23) com f(X) = 1+X +X3
· α0 α1 α2 α3 α4 α5 α6
α0 α0 α1 α2 α3 α4 α5 α6
α1 α1 α2 α3 α4 α5 α6 α0
α2 α2 α3 α4 α5 α6 α0 α1
α3 α3 α4 α5 α6 α0 α1 α2
α4 α4 α5 α6 α0 α1 α2 α3
α5 α5 α6 α0 α1 α2 α3 α4
α6 α6 α0 α1 α2 α3 α4 α5
Fonte: SKLAR, 2001, p. 449.
3.4 PROPRIEDADES BÁSICAS DOS CAMPOS DE GALOIS
Assim como ocorre na álgebra ordinária, polinômios com coeficientes reais podem ter raízes
complexas (sendo o real um subcampo do complexo), polinômios, na álgebra abstrata, com co-
eficientes provenientes de GF(2) podem possuir raízes do seu campo estendido GF(2m) (LIN;
COSTELLO, 2004).
Além disso, sendo f(X) um polinômio com coeficientes de GF(2) e β proveniente de
GF(2m). Se β for uma raiz de f(X), então, para qualquer l ≥ 0, β2l
é também uma raiz de
f(X). Essa propriedade pode ser entendida a partir do desenvolvimento abaixo:
f2
(X) = f(X2
) (3.9)
f2
(X) = (f0 + f1X + f2X2
+···+ fnXn
)2
= [f0 +(f1X + f2X2
+···+ fnXn
)]2
= f2
0 +2 f0(f1X + f2X +···+ fnXn
)+(f1X + f2X2
+···+ fnXn
)2
f2
0 +(f1X + f2X2
+···+ fnXn
)2
aplicando repetitivamente o procedimento acima, tem-se:
f2
(X) = f2
0 +(f1X)2
+(f2X2
)2
+···+(fnXn
)2
considerando que fi = 0 ou 1, então f2
i = fi:
f2
(X) = f0 + f1(X2
)1
+ f2(X2
)2
+···+ fn(X2
)n
= f(X2
)
Essa propriedade permanece verdadeira, sendo l ≥ 0, para
f2l
(X) = f(X2l
) (3.10)

22
portanto,
[f(β)]2l
= f(β2l
) = 0
e β2l
é também raiz de f(X).
O elemento β2l
é chamado conjugado de β. De acordo com a propriedade demonstrada,
se β, um elemento de GF(2m) for raiz de um polinômio f(X) sobre GF(2), então todos os
diferentes conjugados de β, também elementos em GF(2m), são raízes de f(X).
Por exemplo, considerando α, pertencente o campo GF(23), como raiz do polinômio binário
1+X +X3, observa-se que α2,α4,···, são também raízes deste mesmo polinômio e pertencem
a GF(23).

23
4 CÓDIGOS LINEARES EM BLOCO
Para implementação dos algoritmos de codificação de canal, utiliza-se códigos com carac-
terísticas e estruturas específicas que permitem manipulações estratégicas da mensagem como,
por exemplo, os códigos lineares em bloco.
A definição e a descrição dos códigos lineares em bloco ocorrem em termos das matrizes
chamadas geradora e de verificação de paridade. Estas estão relacionadas com, além da estru-
tura do código, o conceito de síndrome, o qual tem papel importante na detecção e correção dos
erros.
4.1 ASPECTOS ESTRUTURAIS
Esta família de códigos em blocos possui como principal característica dividir a sequên-
cia de informação em um conjunto de k símbolos, u = {u1,u2,··· ,uk}, e mapeá-los em uma
sequência maior, chamada palavra código ou vetor de código, de tamanho n, v = {v1,v2,··· ,
vn}. Um exemplo dessa transformação pode ser visto na Tabela 7. O número expresso por k
também é conhecido como dimensão do código, como será visto posteriormente.
Portanto, existem 2k diferentes palavras código correspondentes às 2k mensagens. Denota-
se esse conjunto de palavras e associações como um código em bloco (n, k), com taxa de
codificação dada por R = k/n, a qual pode ser interpretada como o número de símbolos entrando
no codificador de canal, para cada símbolo que é transmitido por ele.
A taxa de codificação máxima é 1, ou seja, quando não há nenhum símbolo de redundância
adicionado (a mensagem não é codificada). Por outro lado, observa-se que quanto mais redun-
dância estruturada é adicionada, a capacidade de correção de erro é maior, ao custo da redução
da taxa de codificação. Portanto, a qualidade do código é maior para aquele que maximiza a
capacidade de correção de erros, mantendo a taxa de codificação o mais próximo da unidade.
Tabela 7 – Relação entre palavras de código e mensagens para um código (6,3)
Mensagem Palavra de Código
000 000000
100 110100
010 011010
110 101110
001 101001
101 011101
011 110011
111 000111
Esses blocos de informação, chamados de mensagem, são independentes entre si (pois
assume-se um canal sem memória). Consequentemente, as operações realizadas não possuem

24
memória e podem ser implementadas através de lógica combinacional (JIANG, 2010).
O conjunto de todas as sequências de n simbolos é chamado de espaço vetorial Vn sobre o
campo GF(q), com q = 2 neste caso, cujas operações de adição e multiplicação estão definidas
nas tabelas 1 e 2, respectivamente. Os elementos de Vn são chamados de vetores, enquanto os
elementos do campo são ditos escalares.
Adiante será necessária a definição de um subespaço, então, o mesmo é caracterizado como
um subconjunto S de Vn, devendo satisfazer duas condições:
• O vetor com todos os elementos nulos pertence à S;
• A soma de quaisquer dois vetores em S também está contida em S.
4.1.1 Linearidade e Matriz Geradora
Um conjunto de 2k sequências de n bits só é chamado de código linear em bloco (n, k) se
for um subespaço k-dimensional do vetor de espaços Vn. Ou seja, qualquer combinação linear
dos vetores deste subespaço k (incluindo o vetor nulo) também será uma palavra código.
Com isso, pode-se verificar que há um conjunto de palavras código, o qual com número
de elementos menor que 2k, capaz de gerar todas as 2k palavras código do subespaço. Ou
seja, sendo C um código linear (n, k), é possível encontrar k palavras código, linearmente
independentes, {g1,g2,··· ,gk} em C, de forma que qualquer vetor de código v é resultado de
uma combinação linear dessas k palavras código geradoras. Isto é,
v = u1g1 +u2g2 +···+ukgk
Agrupando essas palavras código, obtém-se a chamada matriz geradora, G, apresentada a se-
guir:
G =








g1
g2
...
gk








=








g11 g12 g13 ··· g1,n
g21 g22 g23 ··· g2,n
...
...
...
...
gk,1 gk,2 gk,3 ··· gk,n








Sendo a mensagem a ser codificada expressa por u = {u1,u2,··· ,uk}, a palavra de código
correspondente é obtida por:
v = u·G
A utilização de códigos lineares resulta na redução da memória utilizada na implementação
da codificação. Pois ao invés de utilizar tabelas com todas as 2k possibilidades de relação entre
mensagem e palavra código, gera-se apenas a palavra código correspondente a cada mensagem
recebida, através de somente k palavras de códigos.
A matriz G é chamada de geradora, pois como dito anteriormente, gera todos os 2k vetores
do subespaço. O menor conjunto linearmente independente capaz de gerar o subespaço é dito

25
base do subespaço e o número de vetores na base define a dimensão deste. Neste caso, a
dimensão é k.
4.1.2 Códigos Sistemáticos
Sendo n > k, uma palavra código completa contém, além dos k símbolos da mensagem,
(n−k) símbolos de redundância estruturada ou paridade, os quais quando estão implícitos nas
sequências de símbolos do código, caracterizam-no como não sistemático. Por outro lado,
quando a redundância e a mensagem aparecem de maneira explícita na palavra código, o mesmo
é então classificado como sistemático.
Para se obter estrutura sistemática em um código, parte da matriz geradora deve ser a matriz
identidade de dimensões k ×k. Enquanto a outra porção é composta por símbolos de paridade,
os quais são somas lineares dos símbolos de informação, formando a chamada matriz paridade.
G = [P | Ik]
G =








p11 p12 ··· p1,(n−k) 1 0 ··· 0
p21 p22 ··· p2,(n−k) 0 1 ··· 0
...
...
pk1 pk2 ··· pk,(n−k) 0 0 ··· 1








Supondo v uma palavra código gerada pela matriz G, então, devido à estrutura sistemática,
observa-se que
v = p1 p2 ··· pn−k
paridade
m1 m2 ··· mk
mensagem
4.1.3 Matriz de Verificação de Paridade
Existe uma matriz associada à qualquer código linear chamada matriz de verificação de
paridade, denotada por H. Sua principal característica é o fato de que suas linhas geram o
espaço nulo do subespaço definido pelas linhas de G. Isso significa que o produto interno entre
os vetores de G e de H será sempre sempre nulo.
Essa matriz H possui dimensão (n − k) × n, sendo as (n − k) linhas linearmente indepen-
dentes e de forma que qualquer vetor do subespaço das linhas de G seja ortogonal às linhas de
H. Ou ainda, qualquer vetor que seja ortogonal às linhas de H está contido no subespaço das
linhas de G (LIN; COSTELLO, 2004).
A composição da matriz H é dada por,
H = [In−k | PT
]

26
H =








1 0 ··· 0 p11 p21 ··· pk,1
0 1 ··· 0 p12 p22 ··· pk,2
...
...
0 0 ··· 1 p1,(n−k) p2,(n−k) ··· pk,(n−k)








sendo PT a matriz de paridade transposta.
Portanto, analisando o produto interno de uma linha i da matriz G com uma linha j da matriz
H, tem-se
gi ·hj = pij + pij = 0.
Fazendo isso para 0 ≤ i ≤ k e 0 ≤ j ≤ n −k, obtém-se então G ·HT = 0. Dessa maneira, uma
sequência de símbolos n será uma palavra código v, gerada através da matriz G, somente se
v·HT = 0.
4.1.4 Síndrome
Um código (n, k) linear em bloco e sistemático transmite uma palavra código v = {v1,v2,··· ,vn}
através de um canal ruidoso e recebe um vetor r = {r1,r2,··· ,rn}. Supondo a ocorrência de
algum tipo de erro durante a transmissão, o vetor recebido será
r = v+e (4.1)
sendo e = {e1,e2,··· ,en} o padrão de erro introduzido pelo canal. Então, ao receber o vetor
r multiplica-se o mesmo pela matriz de verificação de paridade transposta, com o objetivo de
verificar se r é uma palavra código. O resultado dessa operação é chamado de síndrome:
S = r·HT
(4.2)
se r for uma palavra código válida, então S = 0. Caso contrário, S = 0, significa a ocorrência
de erro e portanto, r = v.
No caso de um sistema de requisição de repetição, o receptor entra em contato com o trans-
missor pedindo o reenvio da mensagem corrompida. Já no caso de correção antecipada, o
receptor realiza, se possível, a correção da mensagem utilizando os dados da síndrome.
Através das Equações (4.1) e (4.2) observa-se,
S = (v+e)·HT
(4.3)
sendo v uma palavra de código, a Equação (4.3) fica
S = e·HT
= {s1,s2,··· ,sn−k}. (4.4)

27
Observa-se que pode ocorrer um padrão de erro igual a uma palavra código. Assim, a soma
da palavra código transmitida v com o padrão de erro inserido pelo canal irá resultar em outra
palavra código, inclusive obtendo S = 0. Estes casos são considerados como não detectáveis,
ou seja, o decodificador não irá corrigir o erro.
Portanto, é possível identificar duas importantes propriedades da matriz de verificação de
paridade, requeridas para ser possível a identificação dos erros:
• Nenhuma coluna de H pode ser formada somente por elementos nulos, pois, do contrário,
a ocorrência de erros não iria afetar o valor da síndrome e não seria possível corrigí-los;
• As colunas de H devem ser únicas. Se duas colunas forem idênticas, os erros nas palavras
códigos correspondentes à essas colunas serão indistinguíveis.
4.1.5 Distância Mínima de um Código em Bloco
A capacidade de detecção e correção de um código em bloco está diretamente ligada à
sua estrutura. Supondo uma palavra código v = {v1,v2,··· ,vn}, o peso de Hamming, um dos
parâmetros que fornece informações a respeito das características do código, é definido como
sendo o número de componentes não nulas do vetor código, sendo denotado por w(v).
Outra definição utilizada para caracterização dos códigos em bloco é a chamada distância
de Hamming, a qual, dadas duas palavras de código u e v, é determinada como sendo o número
de locais em que as componentes dos vetores código diferem, denotada por d(u, v).
Há uma propriedade envolvendo tanto o peso, quanto a distância de Hamming, definindo
que a distância entre duas palavras código é igual ao peso da soma das mesmas. Ou seja,
d(u, v) = w(u+v) (4.5)
Para a determinação da capacidade de detecção e correção de erros aleatórios de um código
utiliza-se a chamada distância mínima do código, dmin. Esse parâmetro é a menor distância
de Hamming entre todas as palavras código. Mas como os códigos lineares em bloco devem
satisfazer a condição de que a soma de quaisquer duas palavras código deve ser outra palavra
código, então é possível se obter a seguinte relação:
d(u, v) = w(u+v) = w(z) (4.6)
Com isso, é possível encontrar a distância mínima através apenas da análise dos pesos das
palavras código, excluindo a totalmente composta por elementos nulos, de forma que o peso
mínimo encontrado será igual à distância mínima do código.
A fim de identificar a relação da distância mínima com a capacidade do código, supõe-se a
transmissão de uma palavra código v através de uma canal ruidoso e a recepção de um vetor r.
Calcula-se a distância entre os vetores, d(v, r) = l. Caso l seja igual à distância mínima dmin,
então o vetor recebido r poderá ser identificado pelo decodificador como outra palavra código

28
que não v, levando-o a cometer um erro. No entanto, se l for igual ou menor a dmin −1, r não
será igual à nenhuma palavra código e o erro será identiﬁcado. Portanto, um código em bloco
com dmin é capaz de detectar todos os padrões de dmin −1 ou menos erros.
Em relação à capacidade de correção, este código é capaz de corrigir até t erros,
t =
dmin −1
2
(4.7)
onde x signiﬁca o maior inteiro que não excede x.
4.1.6 Arranjo Padrão
Na transmissão através de um canal ruidoso, por mais que a palavra código seja distorcida
pelo canal, ela continuará sendo um vetor pertencente ao espaço vetorial Vn. No entanto, caso a
mesma não pertença ao subespaço k, será obtida uma síndrome diferente de zero. Quando isso
acontece é possível relacionar o padrão de erro ocorrido, com o valor da síndrome calculada e
portanto o código poderá ser corrigido. Ao conjunto dessas relações (incluindo a síndrome de
valor zero, com o padrão de erro nulo), dá-se o nome de arranjo padrão.
Baseando-se na estrutura linear do código, o arranjo padrão segue as seguintes regras de
construção. Todas as 2k palavras códigos são distribuídas na primeira linha, formando k colunas,
com o vetor nulo na primeira posição. Para as restantes 2n −2k, escolhe-se as primeiras colunas
de cada linha como sendo o padrão de erro mais provável que possa acontecer, e o restante é
formado pela soma do padrão de erro à palavra código da primeira coluna. Ainda como regra
de construção, cada vetor do espaço Vn aparece somente uma vez no arranjo. Um exemplo de
arranjo padrão é mostrado a seguir:
v1 v2 ··· vi ··· v2k
e2 e2 +v2 ··· e2 +vi ··· e2 +v2k
e3 e3 +v2 ··· e3 +vi ··· e3 +v2k
...
...
...
...
ej ej +v2 ··· ej +vi ··· ej +v2k
...
...
...
...
e2n−k e2n−k +v2 ··· e2n−k +vi ··· e2n−k +v2k
Observe que cada linha é formada por vetores que possuem uma importante característica em
comum, todos possuem o mesmo padrão de erro. Isso leva à outra propriedade importante:
todos os vetores de cada linha terão a mesma síndrome, como pode ser visto na Equação (4.4).
O erro somente será corrigido se o padrão de erro estiver presente na primeira coluna, por-
tanto, um código linear em bloco (n, k) é capaz de corrigir até 2n−k padrões de erro. Como

29
exemplo, em um canal binário simétrico (BSC), padrões de erro com menor peso são mais pro-
váveis, então, na formação de um arranjo padrão para este caso, estes serão os escolhidos para
compor a primeira coluna.
A decodiﬁcação baseada na pesquisa no arranjo padrão, para códigos menores, resulta em
atrasos pequenos. No entanto, para códigos maiores ela torna-se impraticável, tanto pela quan-
tidade grande de informações que deverão ser armazenadas, quanto pela complexidade do cir-
cuitos de lógica combinacional necessários.
Mesmo sendo inviável para codigos maiores, o arranjo padrão pode ser visto como uma
ferramenta organizacional, que permite a visualização de questões importantes, como limites da
capacidade de correção de erros. Um desses limites é o chamado limite de Hamming, descrito
abaixo como
Símbolos de paridade: n−k ≥ log2 1+
n
1
+
n
2
+···+
n
t
(4.8a)
Padrões de erro: 2n−k
≥ 1+
n
1
+
n
2
+···+
n
t
, (4.8b)
onde
n
j
representa o número de maneiras em que os j símbolos podem gerar erros nos n com-
ponentes da palavra código. Observa-se que a soma dos termos de dentro dos colchetes fornece
o número mínimo de linhas necessárias no arranjo padrão para corrigir todas as combinações
de erros de até t símbolos. As inequações (4.8) limitam inferiormente o número de símbolos
de paridade, em função da capacidade de correção t do código. Ou então, elas podem expres-
sar um limite superior para o número de erros que o código pode corrigir, t, de acordo com o
número de símbolos de paridade. Assim, para qualquer código linear em bloco (n, k) prover
a capacidade de correção de t símbolos, é necessário que o limite de Hamming seja satisfeito
(SKLAR, 2001).

30
5 CÓDIGOS CÍCLICOS
Os códigos cíclicos formam uma importante subclasse dos códigos lineares em bloco. Sua
importância se deve ao fato de que sua codificação e cálculo da síndrome podem ser feitos atra-
vés de registradores de deslocamento linear com conexões de realimentação (LFSR), e também
porque este tipo de código possui características estruturais algébricas instrínsecas que permi-
tem diversas maneiras práticas de decodificação.
5.1 ESTRUTURA ALGÉBRICA
Os códigos cíclicos possuem uma importante característica, envolvendo as palavras código,
que se refere ao deslocamento dos seus componentes. Ou seja, supondo uma palavra código
v = {v0,v1,··· ,vn−1}, deslocando seus componentes uma vez para a direita, obtém-se outra
palavra código, a qual é chamada de deslocamento cíclico unitário de v,
v(1)
= {vn−1,v0,··· ,vn−2}
assim, um código linear (n, k) é dito cíclico se cada deslocamento como este, de uma palavra
código, resultar em outra palavra código.
Pode-se expressar as palavras códigos de maneira polinomial. Através desse tipo de repre-
sentação será explicitada a característica cíclica do código. Supondo então, v(X) = v0 +v1X +
v2X2 +···+vn−1Xn−1 um vetor código representado dessa forma, com grau (n−1). Então, ao
dividirmos Xiv(X) por Xn + 1, o resto da divisão inteira será uma palavra código v(i)(X), ou
seja,
Xiv(X)
Xn +1
= q(X)+
v(i)(X)
Xn +1
(5.1a)
Xi
v(X) = q(X)(Xn
+1)+v(i)
(X) (5.1b)
Denota-se essa operação como,
v(i)
(X) = Xi
v(X)mod(Xn
+1)
5.1.1 Polinômio Gerador
Uma das característica que leva os códigos cíclicos a serem implementados de maneira
simples é o fato de que a palavra código relacionada ao polinômio de menor grau é única.
Ou seja, existe somente um polinômio de menor grau no código. A partir disso, define-se
que em um código cíclico (n, k) os seus polinômios consituintes são combinações lineares do
polinômio mínimo, isto é, sendo g(X) = 1+g1X +···+gp−1X p−1 +X p o polinômio de menor

31
grau do código, então um polinômio de grau (n −1) ou menos pertence ao código somente se
for múltiplo de g(X).
O polinômio g(X) é chamado de polinômio gerador, portanto, cada palavra código polino-
mial do subespaço k é da forma v(X) = m(X)g(X), em que v(X) é um polinômio de grau (n−1)
ou menos, enquanto que m(X) é de grau k − 1. A partir disso, define-se o grau do polinômio
gerador como sendo p = n − k. Assim, em um código (n, k), existe apenas um polinômio de
grau (n−k) e para este ser um polinômio gerador deve ser ainda um fator de Xn +1.
A medida que n cresce, Xn +1 vai possuindo mais fatores, alguns desses polinômios geram
bons códigos, outros não. Como selecionar polinômios geradores para produzir bons códigos
cíclicos é um problema muito difícil e bastante estudado por teóricos em códigos (LIN; COS-
TELLO, 2004).
5.1.2 Codificação
Com a definição do polinômio gerador, codifica-se a mensagem através de v(X) = m(X)g(X).
Essa operação é facilmente desenvolvida através de registradores de deslocamento, em que a re-
alimentação é definida pelo polinômio g(X). São os chamados Linear Feedback Shift Registers
(LFSR).
Os códigos cíclicos também podem ser codificados na forma sistemática para redução da
complexidade. Neste caso, os símbolos da mensagem,
m(X) = m0 +m1X +m2X2
+···+mk−1Xk−1
(5.2)
são utilizados como parte do polinômio código (polinômio relacionado com determinada pala-
vra código), mais especificamente nas k ordens mais altas do mesmo. Para realizar essa mani-
pulação, desloca-se a mensagem (n−k) posições para a direita através de multiplicação,
Xn−k
m(X) = m0Xn−k
+m1Xn−k+1
+m2Xn−k+2
+···+mk−1Xn−1
(5.3)
A partir disso, gera-se os símbolos de paridade correspondentes ao restante do polinômio
código, dividindo o polinômio de (5.3) pelo polinômio gerador g(X) e obtendo o resto dessa
divisão,
Xn−k
m(X) = q(X)g(X)+p(X) (5.4)
Através de operações aritméticas, obtém-se,
p(X)+Xn−k
m(X) = q(X)g(X) = v(X) (5.5)

32
Como g(X) possui grau (n−k), o grau de p(X) deve ser (n−k −1) ou menos. Então,
p(X)+Xn−k
m(X) = p0 + p1X +···+ pn−k−1Xn−k−1
+m0Xn−k
+m1Xn−k+1
+···+mk−1Xn−1
correspondendo à palavra código v = p0 p1 ··· pn−k−1
paridade
m0 m1 ··· mk−1
mensagem
.
O circuito de codificação sistemática utiliza também LFSR, no entanto, são necessários mais
alguns detalhes para produzir a palavra código da maneira descrita. Esses detalhes serão vistos
posteriormente.
5.1.3 Matrizes Geradora e de Verificação de Paridade
Todos os polinômios códigos do subespaço k são múltiplos do polinômio gerador g(X) =
g0 + g1X + ··· + gn−kXn−k. Portanto, a matriz geradora deste código possui k polinômios,
g(X),Xg(X),··· ,Xn−kg(X), formando suas k linhas da seguinte maneira,
G =











g0 g1 g2 ··· gn−k 0 0 0 ··· 0
0 g0 g1 g2 ··· gn−k 0 0 ··· 0
0 0 g0 g1 g2 ··· gn−k 0 ··· 0
...
...
...
...
...
0 0 ··· 0 g0 g1 g2 ··· gn−k











Entretanto, a matriz G não está na forma sistemática. Para isto, bastaria realizar algumas ope-
rações nas suas linhas.
Dado que o polinômio g(X) é um fator de Xn +1, tem-se,
Xn
+1 = g(X)h(X) (5.6)
sendo h(X) um polinômio de grau k chamado de polinômio de verificação de paridade. Como
as palavras código são exatamente múltiplas de g(X), verifica-se, utilizando a teoria definida no
capítulo sobre campos de Galois, que
v(X)h(X) = m(X)g(X)h(X) = m(X)(Xn
+1) ≡ 0 (5.7)
assim, para verificar se um polinômio pertence ao conjunto das k palavras código, basta multiplicá-
lo por h(X). Somente se o resultado for nulo o polinômio pertence ao código (MOON, 2005).
Da Equação (5.7), observa-se que as potências Xk,Xk+1,··· ,Xn−1 não existem em m(X)(Xn +
1), já que m(X) tem grau (k − 1) ou menos. Com isso, os coeficientes Xk,Xk+1,··· ,Xn−1 da

33
multiplicação v(X)h(X) devem ser nulos. Dessa maneira, obtem-se as seguintes (n−k) igual-
dades (LIN; COSTELLO, 2004),
k
∑
i=0
hivn−i−j = 0 for 1 ≤ j ≤ n−k (5.8)
Assim, define-se o polinômio recíproco de h(X) como sendo
Xk
h(X−1
) hk +hk−1X +hk−2X2
+···+h0Xk
(5.9)
o qual é utilizado para formar a matriz de verificação de paridade, H, do código gerado por
g(X):
H =











hk hk−1 hk−2 ··· h0 0 0 0 ··· 0
0 hk hk−1 hk−2 ··· h0 0 0 ··· 0
0 0 hk hk−1 hk−2 ··· h0 0 ··· 0
...
... ... ...
...
0 0 ··· 0 h0 hk−1 hk−2 ··· h0











A partir das igualdades de (5.8), observa-se que qualquer vetor do código (n, k) será orto-
gonal a cada linha da matriz H, pois elas formam o código (n, n − k) que constitui o espaço
nulo do subespaço definido por (n, k). Ou seja, G·HT = 0.
5.1.4 Síndrome de Códigos Cíclicos
Sendo um vetor recebido r(X) = r0 +r1X +r2X2 +···+rn−1Xn−1, para verificar se o mesmo
pertence ao código, realiza-se sua divisão pelo polinômio gerador, resultando em
r(X) = q(X)g(X)+s(X) (5.10)
onde s(X) é o polinômio relacionado à síndrome.
A Equação (5.10) também pode ser analisada de outra maneira, relacionando o padrão de
erro ocorrido e(X) com a síndrome. Assumindo que foi transmitida a palavra código v(X) =
m(X)g(X) e o vetor recebido foi corrompido, r(X) = v(X)+e(X), então verifica-se que
e(X) = [m(X)+q(X)]g(X)+s(X) (5.11)
ou seja, a síndrome é obtida através da Equação (5.10) e então pode ser relacionada ao padrão
de erro de acordo com arranjo padrão, como nos códigos lineares em bloco.
Por causa da estrutura cíclica do código, sendo s(X) a síndrome do vetor recebido r(X),

34
então s(1)(X) será a síndrome de r(1)(X). Essa propriedade é útil para a decodiﬁcação, pois
permite realizá-la serialmente. O decodiﬁcador de Meggitt aplica este princípio na sua opera-
ção, buscando um padrão de erro que se manifeste no bit da posição de mais alta ordem, Xn−1.
Para isso, utiliza um circuito combinacional de forma que sua saída é 1 quando a síndrome
corresponde ao padrão de erro corrigível nesta posição.

35
6 CÓDIGOS BCH
Os códigos BCH formam uma classe eficiente de códigos cíclicos de correção de erros.
A partir do BCH binário, generalizou-se para códigos em qm, sendo q primo, ampliando a
abrangência e utilização deste tipo de código. Com isso, vários algoritmos para decodificação
foram concebidos e melhorados com o passar do tempo. Os BCH são considerados os códigos
cíclicos mais importantes e os melhores códigos de tamanho moderado, pois permitem métodos
eficientes de decodificação devido a sua estrutura algébrica específica (JIANG, 2010).
Neste capítulo, será abordada, resumidamente, apenas a subclasse dos códigos BCH biná-
rios. A dos BCH não binários será tratada no capítulo sobre os códigos Reed-Solomon.
6.1 ESTRUTURA ALGÉBRICA
Para quaisquer inteiros positivos m (m ≥ 3) e t (t < 2m−1) existe um código BCH binário
com os seguintes parâmetros:
• Tamanho do bloco: n = 2m −1;
• Número de dígitos de paridade: n−k ≤ mt;
• Distância mínima: dmin ≥ 2t +1.
Este tipo de código é capaz de corrigir qualquer combinação de t erros ou menos, por bloco.
6.1.1 Polinômio Gerador e Codificação
Por ser cíclico, o código possui um polinômio gerador, o qual é especificado em termos
de suas raízes provenientes do campo de Galois GF(2m). Sendo α um elemento primitivo em
GF(2m), o polinômio gerador g(X) é o de menor grau sobre o campo GF(2), que possui
α, α2
, α3
, ··· , α2t
(6.1)
como suas raízes, ou seja, g(αi) = 0 para 1 ≤ i ≤ 2t (LIN; COSTELLO, 2004).
Observa-se que dois campos estão envolvidos na construção de códigos BCH. O campo
GF(2), onde o polinômio gerador possui seus coeficientes e os elementos da palavra código
estão presentes. E o campo estendido, GF(2m), onde o polinômio gerador possui suas raízes.
Assim, como já comentado no capítulo sobre os campos de Galois, os conjugados das
raízes de g(X) também são suas raízes. Portanto, define-se φφφi(X) como o polinômio mí-
nimo de αi. Então, o polinômio gerador deve ser o Mínimo Múltiplo Comum, MMC, de
φφφ1(X), φφφ2(X), ··· , φφφ2t(X),
g(X) = MMC{φφφ1(X), φφφ2(X), ··· , φφφ2t(X)} (6.2)

36
Devido ao fato de que os elementos e seus conjugados possuem o mesmo polinômio mí-
nimo, cada potência par de α, na sequência (6.1), possue o mesmo polinômio mínimo da po-
tência ímpar que a precede. Portanto, o polinômio gerador pode ser reduzido para,
g(X) = MMC{φφφ1(X), φφφ3(X), ··· , φφφ2t−1(X)} (6.3)
Como o grau de cada polinômio mínimo é m ou menos, pois as raízes pertencem ao GF(2m),
g(X) terá grau de no máximo mt, ou seja, o número de símbolos de verificação de paridade do
código, n−k, é no máximo igual a mt.
Para codificar as sequências de mensagem utiliza-se o polinômio gerador. Dessa maneira,
obtem-se a palavra código na forma v(X) = m(X)g(X). O principal elo de ligação entre o
codificador e o decodificador são as raízes do polinômio gerador no primeiro, as quais são
utilizadas no cálculo da síndrome no segundo.
Em relação ao circuito de codificação, utiliza-se também registradores de deslocamento com
realimentação, como no caso dos códigos cíclicos.
6.1.2 Matriz de Verificação de Paridade
Como as raízes do polinômio gerador estão definidas em (6.1) e sendo v(X) = m(X)g(X)
uma palavra código, então
v(αi
) = m(αi
)g(αi
) = m(αi
)0 = 0
isso equivale a
v(α1
) = v0 +v1(α1
)1
+v2(α1
)2
+···+vn−1(α1
)n−1
= 0
v(α2
) = v0 +v1(α2
)1
+v2(α2
)2
+···+vn−1(α2
)n−1
= 0 (6.4)
...
v(α2t
) = v0 +v1(α2t
)1
+v2(α2t
)2
+···+vn−1(α2t
)n−1
= 0
ou então na forma matricial,
(v0, v1, ··· , vn−1)·











1 1 ··· 1
(α1)1 (α2)1 ··· (α2t)1
(α1)2 (α2)2 ··· (α2t)2
...
(α1)n−1 (α2)n−1 ··· (α2t)n−1











= 0

37
Sabendo que a matriz de verificação de paridade deve satisfazer
v·HT
= 0 (6.5)
então, obtém-se a matriz de verificação de paridade para o código BCH descrito:
H =











1 1 ··· 1
(α1)1 (α2)1 ··· (α2t)1
(α1)2 (α2)2 ··· (α2t)2
...
(α1)n−1 (α2)n−1 ··· (α2t)n−1











T
=











1 (α1)1 (α1)2 ··· (α1)n−1
1 (α2)1 (α2)2 ··· (α2)n−1
1 (α3)1 (α3)2 ··· (α3)n−1
...
1 (α2t)1 (α2t)2 ··· (α2t)n−1











De acordo com a definição de projeto dos códigos BCH, a distância mínima é dmin ≥ 2t +1.
Com isso, o código possui capacidade de correção de (dmin −1)/2 = t erros.
Prova-se isso chegando-se a uma inconsistência. Como os códigos BCH são lineares e
em bloco, sua distância mínima é igual ao peso mínimo das palavras códigos não nulas. Su-
pondo que existe uma palavra código v não nula de peso wmin(v) ≤ 2t, então, vj1 = 1, vj2 =
1, ··· , vjw = 1 são os elementos não nulos de v. Portanto, a partir de (6.5), verifica-se,
v·HT
= 0 ⇒ (vj1, vj2, ··· , vjw)·








(α1)j1 (α2)j1 ··· (α2t)j1
(α1)j2 (α2)j2 ··· (α2t)j2
...
(α1)jw (α2)jw ··· (α2t)jw








= 0 (6.6)
⇒ (1, 1, ··· , 1)·








(α j1)1 (α j1)2 ··· (α j1)2t
(α j2)1 (α j2)2 ··· (α j2)2t
...
(α jw)1 (α jw)2 ··· (α jw)2t








= 0 (6.7)
a relação (6.7) implica que cada coluna na matriz w × 2t deve possuir soma zero. Entretanto,
qualquer submatriz quadrática w×w desta matriz é chamada matriz de Vandermonde, na qual
nenhuma coluna possui soma zero (JIANG, 2010). Portanto, é inválida a suposição feita de que
dmin ≤ 2t e então a distância do código excede 2t, ou seja, dmin ≥ 2t +1. Esse limitante inferior
da distância mínima é chamado de limite de BCH.
6.2 DECODIFICAÇÃO DE CÓDIGOS BCH
Similar ao mostrado nos códigos cíclicos, o cálculo da síndrome é feito através da divisão

38
do vetor recebido r(X) pelo polinômio mínimo gerador, obtendo um valor de síndrome para
cada uma das raízes de g(X), como demontrado a seguir,
r(X) = qi(X)φφφi(X)+bi(X) (6.8)
sendo bi(X) o resto da divisão, com grau menor que φφφi(X). Como φφφi(αi) = 0, tem-se
Si = r(αi
) = b(αi
) (6.9)
mas como r(X) = v(X)+e(X), e de (6.4) observa-se que v(αi) = 0, então,
Si = e(αi
) (6.10)
isso significa que a síndrome calculada depende somente do padrão de erro recebido.
Como o decodificador não conhece o padrão de erro recebido, a busca deste é feita através
do calculo da síndrome. No entanto, nos códigos BCH a relação síndrome-padrão de erro não
é procurada explicitamente em um arranjo padrão, como nos casos anteriores, e sim através de
algoritmos específicos que tornam a decodificação mais eficiente.
Então, supondo que ocorra um padrão de erro com v erros nas posições indicadas por
X j1, X j2, ··· , X jv, representado polinomialmente através de
e(X) = X j1
+X j2
+···+X jv
(6.11)
utilizando (6.10) e (6.11) obtém-se, para as 2t raízes de g(X) definidas em (6.1), o seguinte
conjunto de equações:
S1 = (α j1
)1
+(α j2
)1
+···+(α jv
)1
S2 = (α j1
)2
+(α j2
)2
+···+(α jv
)2
(6.12)
...
S2t = (α j1
)2t
+(α j2
)2t
+···+(α jv
)2t
as incógnitas, neste caso, são as posições indicadas por α j1, α j2, ···, α jv
. Esse é o passo mais
complexo da decodificação, pois nota-se que esse conjunto de equações é não linear e possui
muitas soluções, (2k). Dessa maneira, devem ser utilizados métodos específicos apropriados
para encontrá-las, um deles será detalhado no capítulo sobre Reed-Solomon, que também utiliza
essa metodologia de decodificação.

39
7 CÓDIGOS REED-SOLOMON
Os códigos RS pertencem à classe dos BCH não binários, isto é, os elementos da palavra
código são provenientes do campo GF(q), sendo q > 2. Na prática, os códigos RS utilizam
q = 2m. Dessa maneira, para realizar a decodificação, é necessário encontrar, além das posições,
os valores dos erros ocorridos.
Os códigos Reed-Solomon são efetivos tanto para a correção de erros aleatórios, quanto para
erros contínuos. Sendo uma subclasse dos BCH, são considerados códigos lineares em bloco e
com estrutura cíclica.
7.1 CÓDIGOS LINEARES EM BLOCO CÍCLICOS NÃO BINÁRIOS
Os conceitos e propriedades descritos nos capítulos anteriores estavam atrelados à símbolos
binários, entretanto, é possível generalizá-los para aplicação em códigos não binários, ou q-
ários, através de determinadas definições.
Considerando o espaço vetorial de todas as qn sequências de n símbolos sobre GF(q), e
sendo v = v0, v1, ··· , vn−1 e u = u0, u1, ··· , un−1 dois vetores deste espaço, o vetor soma é
definido como
(u0, u1, ··· , un−1)+(v0, v1, ··· , vn−1) (u0 +v0, u1 +v1, ··· , un−1 +vn−1) (7.1)
com a soma ui + vi realizada sobre o campo GF(q). Assim como a soma, a multiplicação é
realizada, por definição, entre os termos de mesma ordem e sobre GF(q).
Assim, um código linear em bloco q-ário é especificado tanto por uma matriz geradora,
quanto pela de verificação de paridade. A codificação e decodificação procedem da mesma
forma do que nos códigos binários, entretanto, as operações são desenvolvidas sobre o campo
GF(q), com q > 2.
Um código q-ário (n, k) cíclico é gerado por um polinômio de grau (n−k) sobre GF(q),
g(X) = g0 +g1X +···+gn−k−1Xn−k−1
+Xn−k
(7.2)
definindo como pertencentes ao código aqueles polinômios que são divisíveis por g(X). Observa-
se que os coeficientes do polinômio gerador pertencem ao campo GF(q).
7.2 DEFINIÇÃO ALGÉBRICA
Um código RS(n, k) corretor de t erros, com símbolos provenientes de GF(q), possui os
seguintes parâmetros:
• Tamanho do bloco: n = q−1;
• Número de dígitos de paridade: n−k = 2t;

40
• Dimensão: k = q−1−2t
• Distância mínima: dmin = 2t +1.
7.2.1 Polinômio Gerador
Assim como nos códigos BCH binários, o polinômio gerador g(X) de um código RS sobre
GF(q), que corrige t erros, possui 2t raízes consecutivas. Entretanto, neste caso, as raízes
pertencem a GF(q). Assim, como tanto os coeficientes, quanto as raízes de g(X) pertencem
ao mesmo campo, GF(q), o polinômio mínimo φφφi(X) é simplesmente (X − αi). Portanto,
assumindo que as raízes sejam, por exemplo, α0, α1, ··· , α2t−1, então,
g(X) = (X −α0
)(X −α1
)···(X −α2t−1
) (7.3)
= g0 +g1X +g2X2
+···+g2t−1X2t−1
+X2t
ou equivalentemente,
g(X) =
2t−1
∏
i=0
(X −αi
) (7.4)
A partir da definição do grau 2t de g(X) e do tamanho do código ser um elemento a menos
do que o alfabeto que o define, observa-se que g(X) gera um código cíclico q-ário de tamanho
n = q−1, com exatamente 2t símbolos de paridade.
Do limitante BCH comentado no capítulo anterior, dmin ≥ 2t + 1. Para não ir contra o
mesmo, nenhum coeficiente de g(X) deve ser nulo, pois do contrário poderia haver alguma
palavra código com peso menor do que 2t + 1. Assim, o polinômio g(X) corresponde a uma
palavra de tamanho 2t +1, implicando no fato de que a distância mínima do código RS gerado
por g(X) é exatamente 2t +1.
7.3 CODIFICAÇÃO
A codificação dos códigos RS(n, k) é semelhante à dos BCH, ou seja, também baseia-se na
multiplicação dos blocos de mensagem pelo polinômio gerador do código. No entanto, a grande
diferença, neste caso, são as raízes utilizadas, as quais possuem as particularidades já comenta-
das acima. Com isso, realiza-se o mapeamento dos blocos de mensagem com k símbolos para
as palavras código de n símbolos. Para o caso de codificação sistemática, procede-se da mesma
forma descrita no capítulo sobre códigos cíclicos.
A arquitetura desenvolvida para a codificação utiliza registradores de deslocamento do tipo
LFSR, pois os códigos RS também são cíclicos. Sua função é calcular, a partir da mensagem, os
2t símbolos de paridade, transmitindo-os no final da sequência de tamanho n. Posteriormente,
esta arquitetura será ilustrada e analisada com mais detalhes.

41
7.4 DECODIFICAÇÃO
Baseando-se no conceito de síndrome introduzido pelos códigos lineares em bloco, na inser-
ção do ponto de vista polinomial dos códigos com estrutura cíclica e da decodificação através de
sistemas de equações não lineares abordada nos códigos BCH cíclicos, o processo desenvolvido
no decodificador RS(n, k) inicia-se no cálculo da síndrome. A partir do resultado desta etapa,
inicia-se a busca da relação correta entre o padrão de erro ocorrido e a síndrome obtida.
Portanto, supondo o vetor recebido r(X) = r0 + r1X + ··· + rn−2Xn−1 + rn−1Xn−1, com
r0, r1, ··· , rn−2, rn−1 pertencentes ao campo de Galois GF(q), dada a transmissão do ve-
tor v(X), cujos elementos também pertencem a GF(q), através de um canal ruidoso, então
considera-se, sendo e(X) o padrão de erro introduzido,
r(X) = v(X)+e(X) (7.5)
Então, calcula-se o polinômio das síndromes, o qual é constituido pelos resultados obtidos
quando substituídas as raízes do polinômio gerador no vetor recebido, ou seja,
S(X) = S1 +S2X +S3X2
+···+S2t−1X2t−2
+S2tX2t−1
(7.6)
onde
Si = r(X)|X=αi para 1 ≤ i < 2t (7.7)
que é equivalente a,
Si = e(X)|X=αi para 1 ≤ i < 2t (7.8)
Nos códigos RS, é necessário encontrar, além das posições de ocorrência dos erros, os
valores dos mesmos. Dessa maneira, o padrão de erro é definido como,
e(X) = ej1X j1
+ej2X j2
+···+ejvX jv
(7.9)
onde ej1, ej2, ··· , ejv são os valores dos erros e X j1, X j2, ··· , X jv são as posições onde os
erros ocorreram, sendo 0 ≤ j1 < j2 < ··· < jv ≤ n−1.
A partir de (7.8) e (7.9), é possível formar um conjunto de equações relacionando as locali-
zações e os valores dos erros, com as síndromes calculadas a partir do vetor recebido.
S1 = ej1(α j1
)1
+ej2(α j2
)1
+···+ejv(α jv
)1
S2 = ej1(α j1
)2
+ej2(α j2
)2
+···+ejv(α jv
)2
(7.10)
...
S2t = ej1(α j1
)2t
+ej2(α j2
)2t
+···+ejv(α jv
)2t

42
por conveniência, para 1 ≤ i ≤ v, define-se,
βi α ji
e δi eji (7.11)
que simplificam a visualização, permitindo observar que essas 2t equações são funções simétri-
cas em β1, β2, ··· , βv, mais conhecidas como funções simétricas soma de potências,
S1 = δ1β1 +δ2β2 +···+δvβv
S2 = δ1β2
1 +δ2β2
2 +···+δvβ2
v (7.12)
...
S2t = δ1β2t
1 +δ2β2t
2 +···+δvβ2t
v
ou então,
Si =
v
∑
j=1
δjβi
j para i = 1, 2, 3, ··· (7.13)
que devem solucionar as t posições e as t magnitudes dos erros, para que seja possível corrigí-
los. Além disso, a solução está ligada ao padrão de erro com o menor número de erros, o que
estará relacionado com o polinômio localizador de erros de menor grau, definido abaixo (LIN;
COSTELLO, 2004).
Utilizando a série geométrica
1
1−βjX
= 1+βjX +β2
j X2
+··· (7.14)
é possível multiplicá-la por δjβb
j e somar, obtendo
v
∑
j=1
δjβb
j
1−βjX
= Sb +Sb+1X +Sb+2X2
+··· (7.15)
sendo a parte esquerda da igualdade a expansão em frações parciais de ΩΩΩ(X)/σσσ(X), onde
σσσ(X) =
v
∏
j=1
(1−βjX) (7.16)
é o chamado polinômio localizador de erros e
ΩΩΩ(X) =
v
∑
j=1
δjβb
j
v
∏
k=1
k=j
(1−βkX) (7.17)
é o chamado polinômio avaliador de erros.

43
Dessa maneira, é possível escrever
ΩΩΩ(X)
σσσ(X)
= Sb +Sb+1X +Sb+2X2
+··· (7.18)
ou até mesmo
σσσ(X)SSS(X) = ΩΩΩ(X)mod(X2t
) (7.19)
mais conhecida como equação chave, definida por Berlekamp.
A partir de (7.16), pode-se escrever,
σσσ(X) = (1−β1X)(1−β2X)···(1−βvX)
= σ0 +σ1X +σ2X2
+···+σvXv
(7.20)
onde σ0 = 1. É possível relacionar as Equações (7.12) e (7.20), obtendo
Sv+1 +σ1Sv +σ2Sv−1 +···+σvS1 = 0
Sv+2 +σ1Sv+1 +σ2Sv +···+σvS2 = 0 (7.21)
...
S2t +σ1S2t−1 +σ2S2t−2 +···+σvS2t−v = 0
Essas equações são conhecidas como identidades de Newton generalizadas. O objetivo é en-
contrar o polinômio mínimo, σσσ(X), do qual os coeficientes satisfazem estas identidades (LIN;
COSTELLO, 2004).
O algoritmo de Berlekamp-Massey encontra, iterativamente, o polinômio σσσ(X) de menor
grau através das síndromes e depois o substitui na equação chave para encontrar ΩΩΩ(X).
Existem outros métodos para isso, como o Euclidiano, ou em frequência. No entanto,
decidiu-se apresentar somente o método de Berlekamp-Massey, porque este é o que foi mais
comentado nas bibliografias consultadas como tendo uma boa relação entre efetividade e com-
plexidade, e, por isso, desenvolvido na parte prática do trabalho.
O processo de encontrar o polinômio localizador de erros através do método de Berlekamp-
Massey não é trivial e para entendê-lo são necessárias algumas observações relacionadas às
propriedades dos registradores do tipo LFSR apresentadas a seguir.
Primeiramente, um LFSR consiste de L estágios, os quais provêem uma combinação linear
que serve de entrada para o primeiro registrador, como mostrado na Figura 2. A saída é obtida
a partir do último estágio, de forma que o conteúdo inicial do LFSR coincide com os primeiros
L símbolos de saída e o restante é obtido com a relação:
sj =
L
∑
i=1
cisj−i para j = L, L+1, L+2, ··· (7.22)

44
onde os símbolos de saída e os coeficientes de realimentação pertencem ao campo GF(q).
Figura 2 – LFSR de tamanho L
Considera-se que o LFSR gera uma sequência finita s0, s1, ··· , sN−1, quando esta coincide
com os primeiros N símbolos de saída para uma inicialização específica. Se L ≥ N, a sequência
é sempre gerada. No entanto, para L < N, o LFSR a gera somente se
sj +
L
∑
i=1
cisj−i = 0 para j = L, L+1, ··· , N −1 (7.23)
Com isso, define-se LN(s) como sendo o tamanho mínimo do LFSR que gera a sequência
s0, s1, ··· , sN−1, de forma que LN(s) ≤ N. No caso deste mesmo LFSR não gerar s0, s1, ··· ,
sN−1, sN, então, o tamanho deve ser alterado da seguinte maneira,
LN+1(s) = máx[LN(s), N +1−LN(s)] (7.24)
Para provar a igualdade acima, Massey (1969) utiliza um algoritmo recursivo que encontra
um LFSR de tamanho LN(s), o qual gera a sequência s dada por s0, s1, ··· , sN−1 para N =
1, 2, 3, ···. Os coeficientes de realimentação formam o chamado polinômio de conexão, que
possui grau máximo LN(s) e é expresso como
c(N)
(X) = 1+c
(N)
1 X +c
(N)
2 X2
+···+c
(N)
LN(s)
XLN(s)
(7.25)
Então, supondo que tenham sido encontrados alguns LN(s) e c(N)(X) para N = 1, 2, ··· , n
através da igualdade (7.24), para N = 1, 2, ··· , n − 1. Agora, busca-se Ln+1(s), c(n+1)(X) e
mostrar que a mesma igualdade se mantém-se para N = n.
A partir de (7.23), encontra-se
sj +
Ln(s)
∑
i=1
c
(n)
i sj−i =



0, j = Ln(s), ··· , n−1
dn, j = n
(7.26)
onde dn, chamada de próxima discrepância, é a diferença entre sn e o (n + 1)-ésimo símbolo
gerado pelo LFSR mínimo encontrado para gerar os primeiros n símbolos da sequência s. Caso
dn = 0, então este LFSR também gera os n + 1 símbolos de s. Portanto, Ln+1(s) = Ln(s) e
c(n+1)(X) = c(n)(X).

45
Mas se dn = 0, então deve ser encontrado um novo LFSR. Para isso, considere m como
sendo o comprimento da sequência gerada antes da última alteração de tamanho do LFSR, ou
seja,
Lm(s) < Ln(s) (7.27a)
Lm+1(s) = Ln(s) (7.27b)
Como a mudança de tamanho foi necessária, Lm(s) e c(m)(X) não são capazes de gerar a
sequência s0, s1, ··· , sm−1, sm. Então, de acordo com (7.23),
sj +
Lm(s)
∑
i=1
c
(m)
i sj−i =



0, j = Lm(s), ··· , m−1
dm = 0, j = m
(7.28)
Seguindo (7.24) para N = m, tem-se
Lm+1(s) = Ln(s) = máx[Lm(s), m+1−Lm(s)]
e considerando (7.27a), então
Ln(s) = m+1−Lm(s) (7.29)
Utilizando essas deﬁnições, forma-se uma nova escolha para o polinômio de conexão,
c(n+1)
(X) = c(n)
−dnd−1
m Xn−m
c(m)
(X) (7.30)
ou seja, o grau c(n+1)(X) é, no máximo,
máx[Ln(s), n−m+Lm(s)] = máx[Ln(s), n+1−Ln(s)] (7.31)
em que a igualdade é obtida considerando (7.29). Com isso, c(n+1)(X) é um polinômio de
conexão válido para o LFSR de tamanho
Ln+1(s) = máx[Ln(s), n+1−Ln(s)] (7.32)
Além disso, a partir das Equações (7.26), (7.28) e da estrutura da (7.30), observa-se,
sj +
Ln+1(s)
∑
i=1
c
(n+1)
i sj−i = sj +
Ln(s)
∑
i=1
c
(n)
i sj−i −dnd−1
m · sj +
Lm(s)
∑
i=1
c
(m)
i sj−i
=



0, j = Ln+1(s), ··· , n−1
dn −dnd−1
m dm = 0, j = n
provando a igualdade deﬁnida em (7.24).

46
O polinômio de conexão comentado é na verdade o polinômio localizador de erros, ou seja,
c(N)
(X) = σσσ(X) (7.33)
enquanto que a sequência finita pré-definida s é o conjunto de síndromes calculadas em (7.7).
Ainda pode ser percebida a equivalência entre as identidades de Newton, definidas em (7.21), e
condição imposta em (7.23). Isso mostra que o problema de sintetização do LFSR na verdade é
uma interpretação física da solução da equação chave.
Com essas definições, é possível encontrar os polinômios localizador e avaliador de erros.
No entanto, suas raízes ainda são desconhecidas. O algoritmo de Chien realiza a busca destas
raízes, para ambos os polinômios, fornecendo as informações necessárias para o algoritmo de
Forney, finalmente, encontrar os valores dos erros.
Observa-se, da definição do polinômio localizador em (7.16), que as raízes deste são inver-
sas às posições dos erros. Assim, o procedimento realizado pelo algoritmo de Chien é calcular
o valor dos polinômios para os elementos do campo, buscando o resultado nulo, o qual é cor-
respondente a uma das raízes, β−1
l , e a uma posição específica βl, consequentemente.
Paralelamente, o mesmo algoritmo de Chien calcula o valor do polinômio avaliador nesta
posição, substituindo a raiz encontrada, β−1
l , na Equação (7.17) e obtendo,
ΩΩΩ(β−1
l ) =
v
∑
j=1
δjβb
j
v
∏
k=1
k=j
(1−βkβ−1
l )
= δlβl
v
∏
k=1
k=l
(1−βkβ−1
l ) (7.34)
E ainda, derivando σσσ(X) em (7.16),
σσσ (X) =
d
dX
v
∏
j=1
(1−βjX) = −
v
∑
j=1
βj
v
∏
k=1
k=j
(1−βkX) (7.35)
e substituindo o valor da raiz, observa-se
σσσ (β−1
l ) = −βl
v
∏
k=1
k=l
(1−βkβ−1
l ). (7.36)
Utilizando (7.34) e (7.36), a expressão para o valor do erro, δl, na posição βl é dada por,
δl =
−ΩΩΩ(β−1
l )
σσσ (β−1
l )
(7.37)
Descoberta por Forney, com ela finaliza-se o processo de decodificação.

47
8 ARQUITETURA DESENVOLVIDA
Após a abordagem das teorias, matemática e de códificação de canal, específicas para o
desenvolvimento dos algoritmos utilizados nos códigos RS, volta-se agora a atenção para a
parte prática, ou seja, para a descrição em VHDL da arquitetura dos blocos necessários para o
funcionamento do codificador e decodificador RS.
O código escolhido para implementação foi o RS(255, 239), de acordo com especificação
da norma G.709/Y1331 (12/2009) da ITU-T, que define a operação em símbolos não-binários,
ou seja, bytes e codificação sistemática. Com isso, observa-se que o campo de operação será o
GF(28) = GF(256), definido pelo polinômio primitivo
f(X) = 1+X2
+X3
+X4
+X8
(8.1)
A distância de Hamming mínima deste código é dmin = 17, portanto, a capacidade de cor-
reção é de até t = 8 bytes. Logo, há 2t = 16 símbolos de paridade adicionados a cada bloco de
239 bytes de informação.
A estrutura deste capítulo será a seguinte: primeiramente, será exposto um bloco comum a
várias partes tanto do codificador, quanto do decodificador, chamado de célula multiplicadora,
depois dar-se-á sequência aos blocos do codificador RS, que se resume praticamente apenas a
um LFSR e, por fim, serão apresentados os blocos do decodificador RS que são o cálculo da
síndrome, algoritmo de Berlekamp, de Chien e de Forney.
8.1 CÉLULA MULTIPLICADORA
Como comentando no capítulo sobre Campos de Galois, as operações aritméticas destes
possuem algumas particularidades. Além disso, são bastante utilizadas no desenvolvimento dos
códigos RS, como no caso da realimentação nos LFSR e em todos os algoritmos de decodifica-
ção, merecendo então atenção específica prévia ao restante dos blocos.
Utilizando a notação polinomial da Tabela 4 para representação dos elementos do campo
GF(23), deseja-se realizar a multiplicação entre dois elementos, a(X) = a0 + a1X + a2X2 e
b(X) = b0 +b1X +b2X2. Para isso, devem ser levadas em conta a multiplicação termo a termo,
a soma dos termos de mesmo grau e ainda a verificação de que todos os resultados pertencem
ao campo. Isso é realizado pela célula multiplicadora apresentada na Figura 3.
Observando a porta lógica AND1, nota-se que ela é responsável pela multiplicação termo a
termo. Já a AND2 refere-se à realimentação de um possível resultado calculado previamente,
de grau superior, que é considerado de acordo com o polinômio primitivo do campo, f(X), no
cálculo atual, ou seja, é o que mantém os resultados como elementos pertencentes ao campo. A
porta XOR1 soma a saída da AND2 com algum possível resultado de mesmo grau já calculado.
Por fim, a porta XOR2 soma todos estes casos, fornecendo a saída final da célula.

48
Figura 3 – Célula Multiplicadora
Utilizar somente uma célula para multiplicação dos polinômios a(X) e b(X) acarretá em
atrasos desnecessários. Assim, podem ser utilizadas várias células em paralelo formando um
circuito combinacional que consome menos tempo para realizar as operações.
A Figura 4 ilustra esse conjunto de células que realizam as operações da Equação (8.2).
a(X)·b(X) = (a2X2
+a1X +a0)·(b2X2
+b1X +b0)
= (a2 ·b2)X4
+(a1 ·b2)X3
+(a0 ·b2)X2
+(a2 ·b1)X3
+(a1 ·b1)X2
+(a0 ·b1)X
+(a2 ·b0)X2
+(a1 ·b0)X +(a0 ·b0)
(8.2)
mas como, neste caso, as operações são realizadas sobre o campo GF(23), o qual é definido
pelo polinômio primitivo f(X) = 1+X +X3, os termos de ordem maior do que 3 são reduzidos
para ordens menores através da divisão por f(X). Foi escolhido um campo de Galois pequeno
para que fosse possível a visualização e o entendimento das operações realizadas. Na Figura 4
observa-se que o resultado c(X) = a(X)·b(X) aparece na saída do conjunto, na parte de baixo,
neste caso, indicado pelos coeficientes c0, c1 e c2.
O bloco que realiza esse agrupamento das células é parametrizável, portanto, a expansão do
conjunto para outros campos é direta.
Como os elementos de GF(256) são bytes, são necessárias 8 × 8 células. O resultado do
conjunto de células, mesmo para GF(256), possui um atraso resultante apenas das portas lógi-
cas envolvidas, pois não há necessidade da utilização de registradores neste bloco.
A Figura 5 mostra a simulação, utilizando a ferramenta ModelSim, de uma multiplicação re-
alizada pelo conjunto de células para este campo, entre os elementos 175−(MSB 10101111 LSB)
e 232 − (11101000), tendo como resultado o valor 208 − (11010000). A validação desta e de
outras operações foram feitas através do programa MATLAB, utilizando a função gf(x,m), que
cria vetores pertencentes ao campo de Galois GF(2m). Após sua criação, basta multiplicá-los
normalmente e verificar o resultado.
Observa-se que o polinômio primitivo gerador do campo é explicitado através da porta f_i,

49
Figura 4 – Conjunto de Células para multiplicação dos polinômios a(X) e b(X)
enquanto aqueles que serão multiplicados utilizam a_i e b_i.
Figura 5 – Simulação de uma operação do conjunto de células
8.2 CODIFICADOR RS
A codiﬁcação implementada baseia-se, como comentado na abordagem teórica, em regis-
tradores de deslocamento chamados LFSR. Esse tipo de registrador utiliza realimentação pa-
rametrizada de acordo com o polinômio gerador do código, g(X), para realizar a divisão da
mensagem já deslocada (códiﬁcação sistemática) e obter os símbolos de paridade.

50
As raízes de g(X) utilizadas também estão definidas na norma G.709 e são as seguintes:
g(X) =
15
∏
i=0
(X −αi
) (8.3)
com αi pertencente a GF(256). Portanto, os coeficientes de g(X) são,
g(X) =α120
+α225
X +α194
X2
+α182
X3
+α169
X4
+α147
X5
+
α191
X6
+α91
X7
+α3
X8
+α76
X9
+α161
X10
+α102
X11
+ (8.4)
α109
X12
+α107
X13
+α104
X14
+α120
X15
+α0
X16
esses coeficientes é que realizam a multiplicação da realimentação do LFSR, como mostrado
na Figura 6.
Além disso, como a codificação é sistemática, a mensagem deve aparecer explicitamente
na palavra código. Assim, inicialmente a chave 1 está fechada e a chave 2 está para baixo, na
posição que permite a saída da mensagem diretamente. Após a passagem de todos os símbolos
referentes à mensagem, a chave 1 é aberta e a 2 é alterada para cima, de forma que os símbolos
de paridade sejam disponibilizados na saída.
No caso do RS(255, 239), passam 239 bytes de mensagem e posteriormente são liberados
16 bytes de paridade, formando ao final um bloco com um total de 255 símbolos.
Figura 6 – Codificador RS(255, 239)
Observa-se que os círculos indicando multiplicação são, na verdade, vários conjuntos de
células similares aquele da Figura 4. Já os círculos sinalizando soma são implementados atra-
vés de operações de ou-exclusivo, XOR, como na Equação (7.1). Os quadrados contendo
L1, L2, ··· ,L2t são os registradores que fornecem em suas saídas as entradas do ciclo de relógio
anterior.
As Figuras 7 e 8 apresentam a simulação da codificação RS(255, 239) para símbolos de in-
formação gerados de forma pseudo-aleatória. Ainda na Figura 8, são apontados os 16 símbolos
de paridade gerados a partir dos 239 símbolos de dados.

51
Figura 7 – Codificação de dados gerados pseudo-aleatoriamente: início
Figura 8 – Codificação de dados gerados pseudo-aleatoriamente: fim
8.3 DECODIFICADOR RS
A decodificação RS implementada é realizada em etapas, sendo que o passo anterior for-
nece informações necessárias para o seguinte. O processo como um todo está representado na
Figura 9 e cada bloco será detalhado separadamente adiante. Esta estrutura de decodificação foi
obtida baseando-se em conceitos teóricos e também através de etapas descritas nas referências
bibliográficas.
Figura 9 – Decodificador RS em blocos
Na Figura 9, é ilustrada a suposição de que o dado recebido apresenta erros. Nota-se que
os dados possuem dois caminhos a seguir inicialmente. Enquanto o ramo de cima passa pelos
algoritmos de detecção e correção de erros, o de baixo é armazenado, ou atrasado, com o intuito
de aguardar os resultados necessários e posteriormente somar-se (pois a soma dos termos iguais,
nos campos GF(2m), é nula, ver Tabela 5) aos erros existentes, fornecendo na saída somente os
dados corretos.

52
8.3.1 Cálculo da Síndrome
A partir da Figura 9, o primeiro bloco a receber dados é o da síndrome. Da teoria, tem-se
que a síndrome é o resultado do cálculo do polinômio recebido nos pontos deﬁnidos pelas raízes
do polinômio gerador do código, ou seja, sendo
r(X) = r0 +r1X +r2X2
+···+r252X252
+r253X253
+r254X254
(8.5)
então
Si = r(X)|X=αi para 0 ≤ i < 15 (8.6)
que pode ser implementado através de unidades lógicas, como ilustrado na Figura 10,
Figura 10 – Unidade de cálculo de síndrome
Essa unidade realiza a operação detalhada abaixo,
Si =r254
r254(αi
)+r253
r254(αi
)2
+r253(αi
)+r252
... (8.7)
r254(αi
)254
+r253(αi
)253
+r252(αi
)252
+···+r2(αi
)2
+r1(αi
)+r0
No entanto, o cálculo desenvolvido por ela considera apenas uma raiz e é concluído somente
após a passagem de todos os dados. Assim, utilizando outras unidades em paralelo, Figura 11,
é possível determinar os valores referentes a cada raíz de g(X) e obter todos os resultados no
mesmo instante. Dessa maneira, forma-se o polinômio de síndromes, S(X) que é repassado ao
bloco seguinte de Berlekamp-Massey,
S(X) = S0 +S1X +S2X2
+···+S14X14
+S15X15
(8.8)
Lembrando que somente no caso do vetor recebido r(X) ser uma palavra código, a síndrome
será nula.
Na Figura 12, apresenta-se a simulação deste bloco para o caso em que não há ocorrência de
erros. Portanto, ao ﬁm do cálculo, o polinômio de síndromes é nulo, como é possível perceber
através do sinal s_o.

53
Figura 11 – Bloco de cálculo de síndrome RS(255, 239)
Figura 12 – Simulação do bloco de síndrome, S(X) = 0
Já a Figura 13 ilustra a situação de ocorrência de erros. Neste caso, o polinômio de síndro-
mes resultante é diferente de zero.
O sinal codeword_length_cnt_s armazena a quantidade de símbolos de entrada do bloco.
Sua variação é de 0 até 254, representando os 255 símbolos do bloco de informação correspon-
dente. Por ﬁm, a porta synd_pol_ok_o indica a presença do polinômio calculado na saída.

54
Figura 13 – Simulação do bloco de síndrome, S(X) = 0
A latência total do bloco de síndromes é de 255 ciclos de relógio.
8.3.2 Berlekamp-Massey
O bloco de Berlekamp-Massey possui como entrada o polinômio das síndromes, S(X), a
partir do qual se encontram os polinômios localizador, σσσ(X), e avaliador de erros, ΩΩΩ(X), de
acordo com a equação chave definida em (7.19) e com o método detalhado de busca do LFSR
de tamanho mínimo.
Assim, a base deste bloco é o algoritmo de Berlekamp tratado da maneira vista por Massey,
da mesma forma como foi desenvolvida a abordagem teórica deste ponto da decodificação. En-
tão, a arquitetura utilizada, presente na Figura 14 é a sugerida pelo artigo de Massey intitulado
Shift-Register Synthesis and BCH Decoding, citado nas referências do trabalho.
O polinômio de síndromes é deslocado, a cada ciclo, para dentro do registrador S mostrado
na Figura 14. Dessa maneira, é possível obter um valor para a discrepância indicada por d.
A partir deste valor, da discrepância de um cálculo passado (indicada por b), e do polinômio
de conexão relacionado com ela, implementa-se, através da lógica superior indicada na figura,
a Equação (7.30). Então, novos valores são adicionados ao registrador C. Assim, ocorrem as
iterações até todo o polinômio de síndromes estiver se deslocado para dentro do registrador S.
Algumas regras de operação devem ser observadas. Para isso, implementa-se uma máquina
de estados descrita nos passos abaixo:
1) Os valores são inicializados, c(X) ← α0; B(X) ← α0; S(X) ← 0; b ← α0; L ← 0; N ← 0.
Então, aguarda-se a confirmação de que o polinômio de síndromes esteja pronto. Quando
a confirmação chega, as síndromes são amostradas e passa-se para o passo seguinte;

55
Figura 14 – Diagrama de blocos do algoritmo de Berlekamp-Massey
2) O valor de N é incrementado de uma unidade. Além disso, o registrador S é deslocado
para a direita e um novo valor de síndrome é inserido na posição inicial do mesmo. Ainda
neste estado, busca-se, em uma memória de valores inversos, o valor correspondente ao
inverso de b. Por fim, desloca-se o registrador B para a direita, preparando-o para um
possível cálculo do novo polinômio de conexão e segue-se para o próximo passo;
3) Realiza-se o cálculo da discrepância, prosseguindo para o próximo estado;
4) Testa-se o valor da discrepância. Se d = 0, passa-se para o estado 7; Se d = 0, calcula-se
um novo polinômio de conexão temporário, T(X), e, caso 2L > N −1 prossegue-se para
o estado 5, senão para 6;
5) Apenas atualiza o valor do polinômio de conexão, c(X) ← T(X) e passa-se para 7;
6) Atualiza os valores, B(X) ← c(X); c(X) ← T(X); L ← N −L; b ← d. Prossegue-se para
o estado 7;
7) Verifica se N = 16. Em caso afirmativo, prossegue-se para o estado final 8. Do contrário,
volta-se para o estado 2;
8) Último estado, atribui o polinômio de conexão à saída referente ao polinômio de localiza-
ção, sinalizando o fim do cálculo deste e zera os registradores utilizados. Por fim, volta-se
ao estado 1, aguardando um novo polinômio de síndromes ficar pronto.
Observa-se que, quando d = 0 não há alteração no polinômio de conexão. No entanto,
quando d = 0 a diferenciação entre os passos 5 e 6 é feita para se obter o LFSR mínimo único
(MASSEY, 1969).

Trabalho de Conclusão de Curso - Fernando Sacilotto Crivellaro

Trabalho de Conclusão de Curso - Fernando Sacilotto Crivellaro

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (16)

Semelhante a Trabalho de Conclusão de Curso - Fernando Sacilotto Crivellaro

Semelhante a Trabalho de Conclusão de Curso - Fernando Sacilotto Crivellaro (20)

Trabalho de Conclusão de Curso - Fernando Sacilotto Crivellaro