Universidade Federal de Pelotas

Instituto de Física e Matemática

Departamento de Matemática, Estatística e Computação
Curso de Bacharelado em Ciência da Computação
Disciplina de Redes de Computadores I

Detecção de Erros em Comunicações de Dados

Alexandre de Oliveira Carreira

Eduardo Rodrigues Gomes

Pelotas
Outubro de 2002
 1 Introdução
A transmissão de informação através de sistemas de comunicação pressupõe a
passagem de sinais através dos meios físicos de comunicação que compõem as redes.
Nesse contexto, diversos fenômenos podem motivar a ocorrência de erros, tais como:
ruídos eletromagnéticos, falhas de sincronização entre transmissor e receptor, indução
devido à proximidade da linha de dados a fios de alta tensão, defeitos em componentes
eletrônicos envolvidos na transmissão/recepção e etc. Na impossibilidade de eliminar
totalmente esses fenômenos, sistemas de comunicação devem ser projetados de forma a
permitir a recuperação da informação perdida ou defeituosa.
O primeiro passo para qualquer esquema de tratamento de erros é a sua detecção.
Reconhecer que um quadro 1 foi recebido com erro irá permitir que se tome as
providências necessárias, que poderão variar de acordo com as necessidades das
aplicações e com as características dos dados transmitidos.
Quando um erro é detectado, existem duas estratégias básicas a se adotar (Figura 1).
Numa, o receptor pode tentar corrigir o erro. Na outra, o receptor simplesmente pede a
retransmissão dos dados. Estas estratégias são conhecidas respectivamente por:
? Códigos de Correção de Erros: Em cada bloco de dados enviado, são
incluídas informações redundantes suficientes para que o receptor possa
deduzir qual a informação correta transmitida;
? Códigos de Detecção de Erros: São incluídas informações suficientes
para o receptor deduzir que houve um erro, mas sem identificar qual, e
solicitar uma nova transmissão.
Nesse trabalho, enfocaremos os códigos de detecção de erros.

Figura 1. Esquema de tratamento de erros.

1
Quadro é a denominação dada a uma quantidade x de bits que é enviada de um transmissor para um
receptor.

2
 2 Códigos de Detecção de Erros
A grande maioria dos métodos de detecção de erros é baseada na inserção de bits
extras na informação transmitida. Esses bits consistem em informação redundante, isto
é, que pode ser obtida através da informação original e o seu conjunto é conhecido por
CheckSum. O CheckSum é computado pelo transmissor através de algum algoritmo que
tem como entrada os bits originais a serem transmitidos. Após computar esses bits, o
transmissor os acrescenta aos bits de informação propriamente dita, para então
prosseguir com a transmissão do quadro. Quando o quadro é recebido, o receptor,
conhecendo o algoritmo utilizado pelo transmissor, pode recomputar os bits de
redundância e compará-los com os respectivos bits recebidos no quadro. Se eles forem
diferentes, detectou-se a presença de um erro.
Para ilustrar melhor o mecanismo de detecção de erros consideremos um
algoritmo para o cálculo do CheckSum que simplesmente soma algebricamente todos os
bits de uma palavra. Então, para a palavra 11001100, o processo seria descrito pelo
esquema abaixo.

Dispositivo Operação Dados

Entrada dos dados originais 11001100
Cálculo do checksum 100
Transmissor
Inserção do checksum nos dados originais 11001100 100
Transmissão dos dados 11001100 100
Erro na transmissão 11001101 100
Recepção dos dados 11001101 100
Cálculo do checksum 101
Receptor
Comparação entre os dois checksums 100 ? 101
Solicita retransmissão

Às vezes, os códigos de detecção de erros são usados para a transmissão de

dados em um canal simplex e não é possível solicitar retransmissões. No entanto, é
preferível que a detecção do erro seja seguida de uma retransmissão. Assim, a forma
mais comum de garantir uma comunicação confiável é dar ao transmissor algum tipo de
aviso sobre o que aconteceu com os dados.
Normalmente, o protocolo pede que o receptor retorne quadros de controle
especiais com confirmações positivas ou negativas sobre os quadros recebidos. Uma
resposta positiva indica que o quadro foi recebido corretamente, uma resposta negativa
aponta que algo saiu errado e que o quadro deve ser retransmitido. Esse processo, num
sistema de redes de computadores, é feito no Nível de Enlace de dados.
Vários algoritmos para a geração de bits de redundância já foram propostos e
podem ser encontrados na literatura. Iremos apresentar alguns desses.

2.1 Ecoplexing

Neste método, o receptor devolve o caractere recebido ao transmissor. O

transmissor então compara visualmente o caractere recebido pelo receptor com o
caractere que foi transmitido. A principal desvantagem deste método é a baixa
eficiência. A Figura 2 ilustra esse método.

3
 Caractere transmitido

Receptor
Transmissor
Caractere recebido

Figura 2. Método de ecoplexing.

2.2 Paridade

A verificação de paridade é um dos mecanismos mais simples para detecção de

erros, a cada caractere transmitido é acrescentado um bit de tal modo que o total de bits
1 seja par (“paridade par”) ou impar (“paridade ímpar”). O equipamento transmissor
calcula o bit de paridade para cada caractere transmitido. O receptor calcula um novo bit
de paridade em cima dos bits recebidos e compara este bit com aquele enviado pelo
transmissor. Se forem iguais, a transmissão é considerada correta, caso contrário, haverá
a necessidade de retransmitir o caractere. A verificação da paridade de cada caractere é
também conhecida por VRC (“Vertical Redundancy Check”). Veja a tabela a seguir:

Caractere ASCII Binário Paridade PAR Paridade Impar

A 41 1000001 1000001 0 1000001 1
B 42 1000010 1000010 0 1000010 1
C 43 1000011 1000011 1 1000011 0

Caso haja um número par de bits com erro, a técnica não consegue detectar, pois
a verificação de bits 1s do caractere recebido permanecerá par ou ímpar. Devido a esta
situação esse método é ineficiente quando existem picos de ruído na linha, que
freqüentemente induzem erros em vários bits consecutivos.
Existem mecanismos melhorados que utilizam a paridade e permitem diminuir
significativamente a probabilidade de um erro não ser detectado.
O LRC (“Longitudinal Redundancy Check”) realiza a mesma operação
longitudinalmente para os caracteres transmitidos num bloco de informação. No final do
bloco é acrescentado um caractere de paridade. Cada bit desse caractere está associado
aos mesmos bits dos caracteres transmitidos. A tabela seguinte exemplifica este
mecanismo para um bloco de 10 caracteres de 8 bits cada:

4
 Paridade
Caractere 1º 2º 3º 4º 5º 6º 7º 8º 9º 10º
(LRC)
bit 0 1 1 0 1 0 1 1 0 1 0 0
bit 1 0 1 0 1 0 1 1 0 1 0 1
bit 2 1 0 0 1 0 0 1 0 0 1 0
bit 3 1 0 0 1 1 0 0 0 0 1 0
bit 4 1 0 1 1 1 1 0 0 0 1 0
bit 5 1 0 1 0 0 1 0 0 1 1 1
bit 6 0 0 0 0 1 1 1 0 1 1 1
bit 7 0 0 0 1 0 0 1 0 1 1 0

2.2.1 Paridade Combinada

Nesse esquema além, além da paridade de caracter, instala-se uma paridade para
o bloco de caracteres, permitindo-se a detecção e recuperação de 1 erro por caracter , a
detecção de dois erros por caracter, e havendo falha de detecção no caso de erros
quádruplos.
A paridade vertical (VRC), consiste em acrescentar um bit de paridade para cada
caracter transmitido. Enquanto que a paridade longitudinal (LRC), consiste em
acrescentar um bit de paridade para cada nível de bit dentro do byte de um bloco,
inclusive para o bit de paridade vertical. À utilização desses dois métodos (VRC +
LRC) em conjunto, dá-se o nome de Paridade Combinada.
A paridade combinada possibilita a formação do bloco de checagem do caracter
(BCC), obtido de todos os bits formados pelo VRC e LRC. Quando a mensagem chegar
ao destino, o equipamento receptor calcula um novo BCC a partir dos bits recebidos e
compara-o com o BCC recebido ao final da mensagem (que foi calculado pelo
equipamento transmissor).
Ocorrendo igualdade entre esses BCCs, a mensagem recebida será considerada
correta, sendo aceita e processada. Caso contrário, a mensagem será considerada
incorreta, pedindo-se assim uma retransmissão.

Paridade
Caractere 1º 2º 3º 4º 5º 6º 7º 8º 9º 10º
(LRC)
bit 0 1 1 0 1 0 1 1 0 1 0 0
bit 1 0 1 0 1 0 1 1 0 1 0 1
bit 2 1 0 0 1 0 0 1 0 0 1 0
bit 3 1 0 0 1 1 0 0 0 0 1 0
bit 4 1 0 1 1 1 1 0 0 0 1 0
bit 5 1 0 1 0 0 1 0 0 1 1 1
bit 6 0 0 0 0 1 1 1 0 1 1 1
bit 7 0 0 0 1 0 0 1 0 1 1 0
Paridade
1 0 0 0 1 1 1 0 1 0
(VCR)

5
2.3 Cyclic Redundancy Check (CRC)

No início deste capítulo, mostramos como uma mensagem corrompida pode ser
detectada através de uma fórmula simples para o cálculo do checksum. Apesar de
funcionar para alguns casos, a fórmula utilizada (soma algébrica dos bits) não é bastante
genérica e pode acontecer de quadros inválidos serem aceitos como válidos
freqüentemente. Por exemplo, a mensagem 11001100 poderia ser corrompida e ser
transformada em 11011000, embora incorreta, a mensagem recebida seria aceita porque
ambas geram 100 como checksum. Esse problema pode ser resolvido usando algum
algoritmo mais sofisticado para o cálculo do checksum.
O método de detecção de erros mais utilizado atualmente é o Código CRC
(cyclic redundancy check), também conhecido código polinomial. A idéia básica dos
algoritmos CRC é dividir a cadeia de bits por uma outra cadeia de bits e utilizar o resto
dessa divisão como checksum. O termo “polinomial” é devido ao fato de os códigos
CRC tratarem as cadeias de bits como polinômios de coeficientes 0 e 1 apenas. Um
quadro de k bits é considerado como o conjunto de coeficientes de um polinômio de k
termos e ordem k-1. Por exemplo, 110001 tem 6 bits e, portanto, representa um
polinômio de 6 termos com os coeficientes 1, 1, 0, 0, 0 e 1: x5 +x4 +x0 .
A aritmética polinomial é feita na base 2, de acordo com as regras da teoria
algébrica. Não há transportes para a adição nem empréstimos para a subtração. Tanto a
adição quanto a subtração são idênticas à operação OU EXCLUSIVO.

0+0=0 0–0=0
0+1=1 0 – 1 = 1 (sem empréstimo)
1+0=1 1–0=1
1 + 1 = 1 (sem transporte) 1–1=1

Assim:

10011011 00110011 11110000 01010101

+11001010 +11001101 - 10100110 - 10101111
01010001 11111110 01010110 11111010

Tendo definido a adição e subtração, passaremos à multiplicação e divisão. A

multiplicação é feita normalmente modificando-se apenas a soma final para que seja
efetuada sem transportes (soma CRC). Então:

1101
x 1011
1101
1101
0000
1101
1111111

A divisão longa é feita da mesma maneira que em código binário, exceto pelo
fato de na subtração não haver empréstimos, como mostrado anteriormente. Diz-se que
um divisor “vai para” o dividendo caso o dividendo tenha tantos bits quanto o divisor.
Para efetuar o cálculo CRC precisamos de um divisor, esse divisor é chamado de
polinômio gerador. Qualquer polinômio pode ser escolhido, porém uns são melhores

6
do que os outros. A magnitude ou ordem do polinômio é muito importante. Ela é a
posição real do bit de maior significância. Assim, o polinômio 11001 tem magnitude m
igual 4 (e não 5) pois será representado pelo polinômio x4 +x3 +x0 .
Escolhido um polinômio gerador, podemos passar ao cálculo CRC. Este é uma
divisão simples dos dados originais pelo polinômio gerador usando a aritmética CRC. O
único truque é que m bits 0, correspondentes à ordem do polinômio gerador, são
concatenados com a mensagem original. Temos:

Mensagem original ? 1101011011

Polinômio gerador ? 10011
Mensagem depois de concatenados os m bits 0 ? 11010110110000

Agora simplesmente dividimos a mensagem aumentada pelo polinômio gerador

usando a aritmética CRC:

1100001010
10011 11010110110000
10011
10011
10011
00001
00000
00010
00000
00101
00000
01011
00000
10110
10011
01010
00000
10100
10011
01110
00000
Resto - - ? 1110

7
 Dessa divisão sai um quociente e um resto. O resto é o nosso checksum.
Usualmente o checksum é concatenado à mensagem original e transmitido. Mas, para
entrar em acordo com a base matemática, que será vista adiante, consideraremos que o
resto da divisão (checksum) será subtraído do polinômio aumentado. No nosso caso, o
quadro transmitido será: 11010110111110.
Ao receber o quadro, o receptor pode fazer duas coisas:
1. Separar a mensagem original do checksum. Calcular o checksum para a
mensagem (depois de concatenar m zeros) e comparar os dois checksums.
2. Calcular o checksum para todo o quadro recebido, se houver algum resto
é porque aconteceu um erro.
As duas opções são equivalentes, porém a segunda é matematicamente mais
limpa. A base matemática para a opção 2 é a seguinte: O quadro recebido deverá ser
divisível (em módulo 2) pelo polinômio gerador. Em qualquer problema de divisão, se
diminuirmos o dividendo pelo resto, o resultado é divisível pelo divisor. Por exemplo,
na base 10, se você dividir 210278 por 10941, o resto será 2399. Quando você subtrai
2399 de 210278, o resto (207879) é divisível por 10941. Por isso, consideramos acima
que o checksum é subtraído do polinômio aumentado.
Para o método do código polinomial ser empregado, o transmissor e o receptor
devem concordar em relação ao polinômio gerador.

2.3.1 Tipos De Erros Detectados Pelo CRC

Agora, vamos analisar a abrangência método CRC. Considere como T(x) o

polinômio enviado e G(x) o polinômio gerador.
Imagine que um erro de transmissão ocorra e que, em vez da seqüência de bits
referentes a T(x), seja recebida a soma T(x)+E(x). Cada bit 1 de E(x) corresponde a um
bit invertido, ou seja, k bits 1 em E(x) significa que k erros de bits simples ocorreram.
Um único erro em rajada (erros duplos, triplos e etc...) é caracterizado por um bit 1
inicial, uma mistura de bits 0 e 1 e um bit 1 final, com todos os outros bits sendo iguais
a 0.
Quando um quadro incorreto é recebido, o receptor o divide por G(x); assim, ele
calcula [T(x)+E(x)]/G(x). T(x)/G(x) é igual a zero; portanto, o resultado do cálculo é
simplesmente E(x)/G(x). Os erros que corresponderem a polinômios contendo G(x)
como fator serão simplesmente ignorados; todos os outros serão detectados.
Se tiver havido um erro simples, E(x) = xi, onde i determina o bit que apresenta
o erro. Se contiver dois ou mais termos, G(x) nunca dividirá E(x); portanto todos os
erros simples serão detectados.
Se tiver havido dois erros isolados, E(x) = xi + xj, onde i > j. Se presumirmos
que G(x) não é divisível por x, uma condição para que todos os erros duplos sejam
detectados é que G(x) não divida xk +1 para qualquer k, até um máximo valor de i – j (ou

8
até o maior tamanho do quadro). São conhecidos polinômios simples, de grau baixo que
protegem quadros longos. Por exemplo, x15 +x14 +1 não dividirá xk +1 para qualquer valor
de k abaixo de 32768.
Se houver um nº ímpar de bits com erros, E(x) conterá um nº ímpar de termos. O
mais interessante é que não há um polinômio com número ímpar de termos que tenha
x+1 como fator no sistema de módulo 2. Ao tornar x+1 um fator de G(x), podemos
detectar todos os erros que consistem em um nº ímpar de bits invertidos.
Para confirmar que nenhum polinômio com um número ímpar de termos será
divisível por x+1, suponha que E(x) tem um nº ímpar de termos e é divisível por x+1.
Fatore E(x) em (x+1)Q(x). Agora avalie E(1)=(1+1)Q(1). Como 1+1=0 (em módulo 2),
E(1) deve ser igual a zero. Se E(x) tiver um nº ímpar de termos, a utilização de 1 no
lugar de x sempre produzirá 1 como resultado. Portanto, nenhum polinômio com um nº
ímpar de termos será divisível por x+1.
Por último, e mais importante, um código polinomial com r bits de verificação
detectará todos os erros em rajada que tiverem um tamanho £r. Um erro em rajada de
tamanho k pode ser representado por xi(xk-1+...1), onde i denota a distância entre a
rajada e a extremidade direita do quadro recebido. Se contiver um termo x0 , G(x) não
terá xi como fator, portanto, se o grau da expressão entre parênteses for menor do que o
grau de G(x), o resto nunca poderá ser igual a zero.
Se o tamanho da rajada for r+1, o restante da divisão por G(x) só será igual a
zero se a rajada for idêntica a G(x). Por definição, o primeiro e o último bits de uma
rajada devem ser iguais a 1; portanto a correspondência entre os valores dependerá do r-
1 bits intermediários. Se todas as combinações forem consideradas como igualmente
prováveis, a probabilidade desse quadro ser aceito como correto é de 1/2r-1.
Também pode acontecer de uma rajada ser maior que r+1 bits, a probabilidade
de um quadro defeituoso passar sem ser percebido é de 1/2r, pressupondo que todas as
seqüências de bits sejam igualmente prováveis. O mesmo acontece com várias rajadas
curtas.

2.3.2 Polinômios Utilizados

Existem polinômios padronizados internacionalmente para uso no método CRC.

Dentre esses, destacamos os quatro principais:

CRC-12 = x12 + x11 + x3 + x2 + x + 1

CRC-16 = x16 + x15 + x2 + 1
CRC-CCITT = x16 + x12 + x5 + 1
CCRC-32 = x32 + x26 +x23 + x22 + x16 + x12 + x11
+ x10 + x8 + x7 + x5 + x4 + x2 + x + 1

Note que todos os quatro contêm x+1 como fator principal.

O CRC-12 é usado com seqüências de caracteres de 6 bits e gera um checksum
de 12 bits.
Tanto o CRC-16 quanto o CRC-CCITT, populares na Europa e EUA
respectivamente, geram um checksum de 16 bits e são usados para caracteres de 8 bits.
Esses dois últimos, detectam todos os erros simples e duplos, todos os erros com um nº
ímpar de bits, todos os erros em rajadas que tiverem um tamanho de no máximo 16 bits,
99,997% de rajadas de 17 bits e 99,998% das rajadas de 18 bits no mínimo.

9
 O CRC-32 foi o escolhido pelo comitê IEEE-8022 para ser utilizado em redes
locais, gerando um cheksum de 32 bits.

2.3.3 Implementações

Uma implementação em hardware do CRC-16 é mostrada na Figura 3. São

usados registradores de trocas (shift registers) e portas OU EXCLUSIVO (exclusive or).
Ao final do processo os valores que ficarem nos registradores serão o CheckSum.

Figura 3. Implementação em hardware do CRC-16

O modelo em software mais simples de se implementar segue o esquema da

implementação em hardware, com operações do tipo “XOR bit a bit” e shifts binários.

2.3.4 Um Quadro Ethernet Típico

Uma estrutura típica de quadro ethernet é mostrada na Figura 2.1. A parte que
nos interessa é apenas os 4 últimos bytes que é a soma de verificação. Essa, trata-se
efetivamente do checksum, ou seja, é o código de verificação de 32 bits calcula a partir
do polinômio CRC-32 apresentado anteriormente.

Bytes 7 1 2 ou 6 2 ou 6 2 0-1500 0-46 4

EndereçoEndereço Soma de
Prêmbulo Dados Enchimento
de Destino
de Origem Verificação
? ?
Início do delimitador de quadro Tamanho do campo de dados

Figura 2.1 Um quadro Ethernet típico (padrão IEEE 802.3)

2
IEEE 802 é um projeto que têm por objetivo elaborar padrões para redes locais de computadores. Foi
instituído pela IEEE Computer Society em fevereiro de 1980

10
 3 Bibliografia

[ALV 94] ALVES, Luiz. Comunicação de Dados, Makron Books, São Paulo. 1994.

[SIL 91] SILVEIRA, Jorge L. Comunicação de Dados e Sistemas de

Teleprocessamento, Makron Books, São Paulo. 1991.

[SOA 95] SOARES, Luiz Fernando G & LEMOS, Guido & Colcher, Sérgio. Das Lans,
Mans, e Wans às Redes ATM, Editora Campus. Rio de Janeiro. 1995

[TAN 94] TANEMBAUM, A. Redes de Computadores. Editora Campus. Rio de

Janeiro. 1994

[WIL 93] WILLIAMS, Ross N. A Painless Guide To Crc Error Detection

Algorithms . Disponível por WWW em
http://www.geocities.com/SiliconValley/Pines/8659/crc.htm (04, outubro,
2002)

11