Captulo

1
Deteco de Erros
Errar humano. Perdoar no a poltica da empresa (As 100 melhores leis de Murphy)

Autor: Constantino Seixas Filho UFMG Departamento de Engenharia Eletrnica

Deteco de Erros
Erros de transmisso de dados podem ter diversas causas: Rudo Distores Branco Impulsivo Atenuao em amplitude Retardo de fase Deslocamento de freqncia

Rudos em geral ocorrem em rajadas (bursts): Imagine uma rajada de 10 ms sobre uma comunicao de 9600 bps: 96 bits de dados sero atingidos. A natureza de erros em rajada muito importante para a deteco de erros.

Tcnicas Primitivas de deteco: Paridade simples ou paridade vertical ou TRC (Transverse Redundancy Check)
A cada caracter adicionamos um bit de paridade. Paridade par Paridade mpar O nmero total de 1s na palavra considerando-se o bit de paridade par. O nmero total de 1s na palavra considerando-se o bit de paridade mpar.

Seja o caracter: 01001100 Vamos calcular o bit de paridade mpar: 0 1 0 0 1 1 0 0 0

Determine a expresso para clculo do bit de paridade mpar em uma palavra de 8 bits:

Pi =
Determine a expresso para clculo do bit de paridade par em uma palavra de 8 bits:

Pp =
2
CRC UFMG - Constantino Seixas Filho

Vamos calcular a eficincia de utilizao de bits para este cdigo:

e=

8 8+1

= 88.8%

Em geral este bit calculado pelo hardware de transmisso de dados (USART) e recebido, verificado e retirado pelo hardware de recepo. Qual a capacidade de deteco de erros deste algoritmo ? Apenas erros em um nmero mpar de bits so detectados.
Exemplo1:

Caracter transmitido: 0 1 0 0 1 1 0 0 0

Caracter recebido: 0 1 1 0 1 1 0 0 0

A paridade calculada na recepo 1 o que contraria o valor do ltimo bit da palavra e o erro detectado.
Exemplo2:

Caracter transmitido: 0 1 0 0 1 1 0 0 0

Caracter recebido: 0 1 1 0 1 0 0 0 0

Existem dois bits trocados. O valor do bit de paridade calculado na recepo 0. Como o ltimo bit da palavra que corresponde ao bit de paridade recebido tambm 1, o erro no detectado.

CRC UFMG - Constantino Seixas Filho

Paridade Horizontal ou LRC (Longitudinal Redundancy Check)

Considere o bloco de dados a serem transmitidos: 1 1 0 1 1 1 0 1 0 1 0 1 1 0 1 1 0 0 1 1 1 1 0 1 0 0 1 0 1 1 1 1 0 0 0 1 1 1 1 0 1 1 0 1 0 1 1 0 0 1 1 0 1 0 Caracter 1 Caracter 2 Caracter 3 Caracter 4 Caracter 5 Caracter de checagem

O ltimo caracter representa a paridade dos caracteres anteriores calculada na vertical bit a bit. Eficincia de utilizao de bits para este cdigo: Supondo um bloco de 5 caracteres:

e=

8* 5 9*6

= 74.1%

A eficincia aumenta quando aumentamos o tamanho do bloco. Dois erros em caracter so detectados. Dois erros em bits de mesma ordem em dois caracteres no so detectados. Outros cdigos de deteco longitudinal de erros so normalmente implementados em automao. A maior parte no usa bits de paridade, mas uma palavra gerada pela soma de todos as demais palavras da mensagem. Esses cdigos so conhecidos pelo nome genricos de Checksum.

CRC UFMG - Constantino Seixas Filho

Cdigos Cclicos de Deteco de Erros: CRC Cyclic Redundancy Code

So capazes de detectar uma grande faixa de erros de transmisso, isolados ou em rajadas. Possuem algoritmo de clculo mais complexos. Podem ser calculados por hardware ou software.

Princpio:
1. Cada bit da mensagem m codificada em binrio, considerado como um coeficiente de um polinmio M(X) base 2. 2. A mensagem deslocada para a esquerda de r posies, onde r o nmero de bits do CRC (ordem do polinmio verificador = nmero de bits da representao do polinmio verificador 1). 3. A mensagem deslocada dividida por um polinmio caracterstico G(X). 4. O resto da diviso somado mensagem deslocada para formar a mensagem composta T(X). 5. T(X) transmitida. 6. O receptor divide T(X) por G(X). 7. Se o resultado for 0, existe grande probabilidade da mensagem estar correta, caso contrrio, existe um erro.
Exemplo1:

Seja a mensagem: 110101 O polinmio correspondente :

1+ X + X

+ X

1 1 0 1 0 1
A palavra foi invertida julgando que a mensagem seria transmitida do LSb para o MSb (LSb primeiro).
Exemplo2:

No prximo exemplo vamos considerar a transmisso no sentido inverso: MSb primeiro. Mensagem: M(X) = 110011 ( X + X + X + 1 ) 4 3 Polinmio: G(X) = 11001 ( X + X + 1 ) Clculo do CRC:
CRC UFMG - Constantino Seixas Filho
5 4

M(X): 1100110000
Primeiro bit a ser transmitido

11001 100001

: G(X) : quociente

11001 0 10000 11001 1001

Resto = CRC

T(X) = 1100111001 Observe que toda a aritmtica empregada base 2. Vamos aplicar o algoritmo de recepo:

M(X): 1100111001 11001 0 11001 11001 0000

11001 100001

: G(X) : quociente

Resto = CRC

Como o resto foi 0, nenhum erro foi detectado.

Anlise Matemtica:
Seja M(X) a mensagem a ser transmitida e seja G(X) o polinmio verificador. Representao Mensagem original Mensagem deslocada: Binria m m 0 0 .... .... 0 r Polomial

M (X )
X rM (X )

Formao da mensagem:

X r M ( X ) = Q( X )G ( X ) + R ( X )

X r M ( X ) R( X ) = Q( X )G ( X ) = T ( X )
T ( X ) = X r M ( X ) + R( X )
Observe que em mdulo 2 as operaes + e se eqivalem T(x) equivalente nossa mensagem composta.

CRC UFMG - Constantino Seixas Filho

Transmisso:

T(X)
Na recepo:

erros ------------

T(X) + E(X)

T ( X ) + E( X ) T ( X ) E( X ) = + G( X ) G( X ) G( X )
Resto = 0

Resto <> 0: Erro detectado No houve Erro, ou Resto = 0: G(x) fator de E(x): Erro no detectado

Polinmios verificadores:
Os polinmios so projetados para detectar erros que possuem certas caractersticas. A referncia [Peterson 61] apresenta todos os teoremas, demostrando as propriedades destes polinmios.
Erros simples

Teorema 1: Um polinmio G(X) com mais de um termo capaz de detectar qualquer erro simples. G(X) = X + 1 // G(X) com dois termos E(X) = X i E=2i i a ordem do bit contada partir da direita. i=0 para o LSb. Demonstrao: Para que ocorra deteco de erros simples, necessrio que G(X) no divida X i . (X+1) no divide X i , assim como nenhum polinmio de grau maior de 1.
Nmero mpar de erros

Teorema 2: Todo polinmio divisvel por X + 1 tem um nmero par de termos. A conseqncia que X+1 detecta no s qualquer erro simples como tambm qualquer nmero mpar de erros. Demonstrao: (por absurdo) E(X) tem um nmero mpar de termos. Vamos supor E(X) seja divisvel por (X+1): E(X) = (X+1) Q(X)
CRC UFMG - Constantino Seixas Filho

Para X = 1 => E(1) = (1+1) Q(1) = 0 . Q(X). E(1) = 0 Mas E(X) =1 para X = 1 porque E(X) tem um nmero mpar de termos. Logo, chegamos a um absurdo.
Erro de 2 bits

E=2i+2j (i > j e i j = k) E(X) = X j ( X i - j + 1 ) G(X) no deve dividir Xk + 1

Erros em rajada (burst)

Definio: Rajada de tamanho k: qualquer padro de erro no qual o nmero de smbolos entre o primeiro e o ltimo erro, incluindo estes erros k.

E(X ) = X

+ ... + X

j>i

Comprimento da rajada = k = j i + 1

E(X ) = X

+ X

+ X

=000100110000000 O comprimento da rajada acima k = 5.

E(X ) = X i(X

ji

+ ... + 1)

E ( X ) = X i E1 ( X )
G(X) no pode ser um divisor de E1 (X). Alternativas Capacidade de deteco k <= r G(X) no pode ser um divisor de E1 (X) e portanto o polinmio capaz de detectar qualquer rajada de comprimento inferior ou igual sua ordem. k = r +1 j i + 1 = r + 1 ou j - i = r. Existem r-1 bits no meio da rajada que podem assumir o valor 0 ou 1. Pode-se demonstrar que a probabilidade de que o pattern de E1 (X) coincida com G(X) :

P=
k>r+1

1 2 r 1
1 2r

P=

Polinmios mais utilizados:

CRC UFMG - Constantino Seixas Filho

CRC-16

16

+ X

15

+ X

+1

CRC-CCITT

16

+ X

12

+ X

+1

CRC-12

12

+ X

11

+ X

+ X

+ X +1

Usado em sistemas sncronos que utilizam caracteres de 8 bits. Detecta erros: Todos simples Todos duplos Todos com nmero mpar de bits Todas rajadas de comprimento <= 16 99.997% das rajadas de comprimento 17 99.998% das rajadas >= 18 bits Sistema mais usado na Europa. Detecta rajadas de comprimento at 16 e mais de 99% das rajadas de comprimento maior que 16. Usado em sistemas sncronos utilizando caracteres de 6 bits. Detecta rajadas de comprimento at 12.

CRC UFMG - Constantino Seixas Filho

Clculo do CRC:
O mtodo de diviso polinomial que serviu de referncia a este estudo no usado na prtica por ser muito trabalhoso. Seja a mensagem: M(X) = 000000000000001 Considerando que vamos enviar o LSb primeiro, a mensagem fica: MLSb(X) = 100000000000000 Polinmio: G(X) = CRC16 = 11000000000000101 Clculo do CRC atravs de diviso polinomial: Primeiro bit a ser enviado 1000 0000 0000 0000 0000 0000 0000 0000 1 1000 0000 0000 0101

: G(X)

1100 0000 0000 0010 1 1 1111111111111101 : quociente 100 0000 0000 0010 10 2 110 0000 0000 0001 01 3 10 0000 0000 0011 110 4 11 0000 0000 0000 101 5 1 0000 0000 0011 0110 6 1 1000 0000 0000 0101 7 1000 0000 0011 0011 0 8 1100 0000 0000 0010 1 9 100 0000 0011 0001 10 10 110 0000 0000 0001 01 11 10 0000 0011 0000 110 12 11 0000 0000 0000 101 13 1 0000 0011 0000 0110 14 1 1000 0000 0000 0101 15 1000 0011 0000 0011 0 16 1100 0000 0000 0010 1 17 100 0011 0000 0001 10 18 110 0000 0000 0001 01 19 10 0011 0000 0000 110 20 11 0000 0000 0000 101 21 1 0011 0000 0000 0110 22 1 1000 0000 0000 0101 23 1011 0000 0000 0011 0 24 1100 0000 0000 0010 1 25 111 0000 0000 0001 10 26 110 0000 0000 0001 01 27 1 0000 0000 0000 1100 28 Primeiro bit a ser enviado 1 1000 0000 0000 0101 29 1000 0000 0000 1001 30 Resto = CRC

10 CRC UFMG - Constantino Seixas Filho

Clculo do CRC atravs de hardware

Pode-se projetar um circuito formado por um registrador de deslocamento (shift register) de r bits, sendo r o nmero de bits do CRC, realimentado por portas XOR. Este tipo de circuito denominado mquina seqencial linear. Uma cobertura completa da teoria envolvendo este tipo de circuito pode ser encontrado em [Kohavi 78]. A teoria dos circuitos seqenciais lineares so utilizados para projetar circuitos capazes de realizar a multiplicao e diviso polinomial em diversas bases numricas. Cada estgio de um registrador de deslocamento representa um atraso no sinal de entrada. Seja o circuito que sintetiza a funo: z(t) = x(t) + x(t-1) + x(t-3) Usando o operador de atraso D (Delay) podemos escrever:
z = x + Dx + D 3 x

ou

z = D3 + D + 1 x
O circuito que sintetiza esta funo denominado de registrador de deslocamento feedforward: x

Figura 1: Realizao da funo z = x + Dx + D 3 x . Este circuito tambm realiza a multiplicao polinomial base 2. A mquina que realiza a diviso polinomial (funo inversa) dada por: x x y + Figura 2: Mquina inversa da figura 1.
CRC UFMG - Constantino Seixas Filho

11

A funo realizada :

y = D ( x + D 2 x ) ou y = Dx + D 3 x x = y+ z z = x y = x + y = D 3 x + Dx + x z = D 3 + D + 1 ou x x 1 = 3 z D + D +1
Observe que neste circuito z a entrada e x a sada. O circuito utilizado na prtica traduz o algoritmo de diviso polinomial e dado por:

x1 + LSB Figura 3: Circuito utilizado na prtica +

x3 z

Para obter este circuito: P(X) = X3 + X + 1 Representao binria: P = 1 0 1 1 Inverte-se a seqncia: Q = 1 1 0 1 Elimina-se o bit menos significativo: Qr = 1 1 0 Cada 1 marca o incio de um registrador de deslocamento (shift register). O valor a ser usado em nossos futuros algoritmos ser justamente Qr = 1 1 0, que marca as posies das portas ou-exclusivo no registrador de deslocamento de ordem 3 (3 posies). A este valor chamaremos de Operando. Este circuito realiza a diviso polinomial base 2 e o circuito utilizado para o clculo do CRC.

12 CRC UFMG - Constantino Seixas Filho

Exemplo:

Mensagem = 10100001 (LSB primeiro) Polinmio = 11001

Figura 4 Comparao do clculo por diviso longa e por circuito emulador CRC = 1101 Em seguida vamos apresentar os circuitos de clculo de CRC para os principais polinmios utilizados.

CRC UFMG - Constantino Seixas Filho

13

CRC_12

Mensagem

Figura 5: Clculo de CRC usando CRC_12 Seqncia de transmisso [McNamara 88] O registrador inicialmente zerado. O string de dados combinado bit a bit com o contedo do registrador de deslocamento. A cada bit as operaes de xor so realizadas e o contedo do registrador deslocado de uma posio para a direita. Quando todos os bits da mensagem tiverem sido processados, o contedo do registrador anexado ao final da mensagem (LSB primeiro). A operao XOR deve ser realizada antes do deslocamento.

14 CRC UFMG - Constantino Seixas Filho

CRC_CCITT

Figura 6: Clculo de CRC usando CRC_CCITT Seqncia de transmisso [McNamara 88]

CRC UFMG - Constantino Seixas Filho

15

CRC-16

Figura 7: Clculo de CRC usando CRC_16 Seqncia de transmisso [McNamara 88]

16 CRC UFMG - Constantino Seixas Filho

CRC-16: RECEPO

Figura 8: Clculo do CRC na recepo

Clculo do CRC bitwise

Os algoritmos de clculo do CRC por software bit a bit so denominados algoritmos bitwise. Estes algoritmos em geral simulam a ao da implementao por hardware.

CRC UFMG - Constantino Seixas Filho

17

// // // //

Clculo do CRC bitwise Autor: Constantino Seixas Filho Data: 7/01/2001

#include <stdio.h> #include <string.h> unsigned CalcCRC(char *,int, unsigned ); unsigned CalcCRC2(char *,int, unsigned ); #define CRC_CCITT 0x8408 #define CRC_16 0xA001 char Mensagem[] = "Primeiro teste de CRC"; char Tabela[] = {0x01, 0x00}; // Exemplo da figura 13-8 McNamara void main() { unsigned Result; Result = CalcCRC(Mensagem, strlen(Mensagem), CRC_CCITT); printf("CRC_CCITT calculado = %04x\n", Result); Result = CalcCRC(Tabela, 2, CRC_16); printf("CRC_16 calculado = %04x\n", Result); Result = CalcCRC2(Mensagem, strlen(Mensagem), CRC_CCITT); printf("CRC_CCITT calculado = %04x\n", Result); Result = CalcCRC2(Tabela, 2, CRC_16); printf("CRC_16 calculado = %04x\n", Result); } // main

unsigned CalcCRC(char *pch, int nBytes, unsigned Operando) { unsigned CRC; int bit0; CRC = 0; // Inicializa shift register para zero for (int cByte = nBytes; cByte >0; --cByte) { CRC ^= (*pch++ & 0x00FF); // Assegura que trabalhar com byte for (int cBit=8; cBit >0; --cBit) { bit0 = 1 & CRC; CRC >>= 1; if (bit0 == 1) CRC ^= Operando; } } return (CRC); // CalcCRC

18 CRC UFMG - Constantino Seixas Filho

unsigned CalcCRC2(char *pch, int nBytes, unsigned Operando) { unsigned CRC; unsigned Dado; int Bit; CRC = 0; // Inicializa shift register para zero for (int cByte = nBytes; cByte >0; --cByte) { Dado = *pch++ & 0x00FF; // Assegura que trabalhar com byte for (int cBit=8; cBit >0; --cBit) { Bit = (Dado & 1) ^ (CRC & 1); CRC >>= 1; Dado >>= 1; if (Bit == 1) CRC ^= Operando; } } return (CRC); // CalcCRC2

O algoritmo 2 sintetiza exatamente o algoritmo fornecido por McNamara, emulando o circuito com os registradores de deslocamento. Observe que aplicar um clock no registrador de deslocamento eqivale a realizar um shift para a direita do valor que representa o contedo do registrador e em seguida realizar um XOR do bit mais significativo do registro com o bit que alimenta a cadeia (XOR do dado com LSb do registrador): Situao antes do pulso de clock: 1 0 D Q D Q 1 D Q 0

Situao aps o pulso de clock: X 1 D Q D Q 0 D Q 1

Simulao atravs de registrador: 0 0 1 1 0 0 0 1 1 Situao antes do clock Registrador aps deslocamento Registrador aps XOR com 100

Alimentar 1 em um registrador de deslocamento = shift right + XOR 1000...

CRC UFMG - Constantino Seixas Filho

19

O primeiro algoritmo mais eficiente pois combina o byte de dados com o CRC uma nica vez e depois toma a deciso de combinar o operando com o CRC apenas em funo do contedo do CRC.

Clculo do CRC bytewise

Um algoritmo mais eficiente foi publicado pela primeira vez na referncia [Perez 83] e passou a ser adotado em todas as implementaes prticas por oferecer um algoritmo muito mais eficiente (cerca de 6 vezes mais rpido, segundo minhas observaes). Vamos observar passo a passo o clculo do CRC 16 e o contedo do shif register aps cada operao: Conveno: Contedo inicial do registrador de deslocamento: C0..C15 Mensagem de entrada: M0..M7 a) Posio inicial:
SH 0 IN * R15 C15 R14 C14 * R13 C13 R12 C12 R11 C11 R10 C10 R9 C9 R8 C8 R7 C7 R6 C6 R5 C5 R4 C4 R3 C3 R2 C2 R1 C1 * R0 C0

b) Posio aps primeiro passo:

SH 1 IN M0 R15 C0 M0 R14 C15 R13 C14 C0 M0 R12 C13 R11 C12 R10 C11 R9 C10 R8 C9 R7 C8 R6 C7 R5 C6 R4 C5 R3 C4 R2 C3 R1 C2 R0 C1 C0 M0

c) Posio aps dois passos:

SH 2 IN M1 R15 C1 C0 M0 M1 R14 C0 M0 R13 C15 C1 C0 M0 M1 R12 C14 C0 M0 R11 C13 R10 C12 R9 C11 R8 C10 R7 C9 R6 C8 R5 C7 R4 C6 R3 C5 R2 C4 R1 C3 R0 C2 C1 C0 M0 M1

20 CRC UFMG - Constantino Seixas Filho

c)
SH 8

Posio aps oito passos (omitindo o smbolo ):

IN M7 R15 C7 C6 C5 C4 C3 C2 C1 C0 M0 M1 M2 M3 M4 M5 M6 M7 R14 C6 C5 C4 C3 C2 C1 C0 M0 M1 M2 M3 M4 M5 M6 R13 C5 C4 C3 C2 C1 C0 M0 M1 M2 M3 M4 M5 C7 C6 C5 C4 C3 C2 C1 C0 M0 M1 M2 M3 M4 M5 M6 M7 R12 C4 C3 C2 C1 C0 M0 M1 M3 M4 C6 C5 C4 C3 C2 C1 C0 M0 M1 M2 M3 M4 M5 M6 C1 R11 C3 C2 C1 C0 M0 M1 M3 C5 C4 C3 C2 C1 C0 M0 M1 M2 M3 M4 M5 R10 C2 C1 C0 M0 M1 M2 C4 C3 C2 C1 C0 M0 M1 M2 M3 M4 R9 C1 C0 M0 M1 C3 C2 C1 C0 M0 M1 M2 M3 R8 C0 M0 C2 C1 C0 M0 M1 M2 R7 C15 C1 C0 M0 M1 R6 C14 C0 M0 R5 C13 R4 C12 R3 C11 R2 C10 R1 C9 R0 C8 C7 C6 C5 C4 C3 C2 C1 C0 M0 M1 M2 M3 M4 M5 M6 M7

Realizando as simplificaes: a) Xi = Ci Mi b) A B = B A (comutatividade) c) A B C = A C B (associatividade) d) A A = 0 (involuo) e) A 0 = A (elemento neutro) Obtemos:

SH 8 IN M7 R15 X7 X6 X5 X4 X3 X2 X1 X0 R14 X6 X5 X4 X3 X2 X1 X0 R13 X7 X6 R12 X6 X5 R11 X5 X4 R10 X4 X3 R9 X3 X2 R8 X2 X1 R7 C15 X1 X0 R6 C14 X0 R5 C13 R4 C12 R3 C11 R2 C10 R1 C9 R0 C8 X7 X6 X5 X4 X3 X2 X1 X0

Observe que os 8 bits menos significativos so funo de C8..C15 e de X0..X7. Os 8 bits mais significativos so funo de X0..X7

CRC UFMG - Constantino Seixas Filho

21

SH 8

IN M7

R15 0 X7 X6 X5 X4 X3 X2 X1 X0

R14 0 X6 X5 X4 X3 X2 X1 X0

R13 0 X7 X6

R12 0 X6 X5

R11 0 X5 X4

R10 0 X4 X3

R9 0 X3 X2

R8 0 X2 X1

R7 C15 X1 X0

R6 C14 X0

R5 C13

R4 C12

R3 C11

R2 C10

R1 C9

R0 C8 X7 X6 X5 X4 X3 X2 X1 X0

Algoritmo: Para todos os bytes da mensagem faa: 1. Calcule Xi = Low(CRC Mensagem) 2. Deslocar o CRC oito bits para a direita. 3. Calcular o valor combinado da funo dos Xis abaixo da linha horizontal 4. Realizar o ou exclusivo do CRC com o valor calculado Observe que uma vez escolhido X (existem 256 possibilidades), o valor calculado no passo 3 fica determinado. Logo podemos pr calcular estes valores e guardalos em uma look up table.
X 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 VALOR 0000 COC1 C181 0140 C301 03CO 0280 C241 C601 06CO 0780 C741 0500 C5C1 C481 044D CC01 0CCO 0D80 CD41 0F00 CFC1 CE81 0E40 0A00 CAC1 CB81 0B40 C901 09CO 0880 C841 X 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 55 57 58 59 60 61 62 63 VALOR D801 18C0 1980 D941 1B00 DBC1 DA81 1A40 1E00 DEC1 DF81 1F40 DD01 1DC0 1C80 DC41 1400 D4C1 D581 1540 D701 17CO 1680 D641 D201 12CO 1380 D341 1100 D1C1 D081 1040 X 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 VALOR F001 30C0 3180 F141 3300 F3C1 F281 3240 3600 F6C1 F781 3740 F501 35CO 3480 F441 3C00 FCC1 FD81 3D40 FF01 3FCO 3E80 FE41 FA01 3ACO 3B80 FB41 3900 F9C1 F881 3840 X 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 VALOR 2800 E8C1 E981 2940 EB01 2BCO 2A80 EA41 EE01 2ECO 2F80 EF41 2D00 EDC1 EC81 2C40 E401 24CO 2580 E541 2700 E7C1 E681 2640 2200 E2C1 E381 2340 E101 21CO 2080 E041 X 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 VALOR AO01 60CO 6180 A141 6300 A3C1 A281 6240 6600 A6C1 A781 6740 A501 65CO 6480 A441 6C00 ACC1 AD81 6D40 AF01 6FCO 6E80 AE41 AA01 6ACO 6B80 AB41 6900 A9C1 A881 6840 X 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 VALOR 7800 B8C1 B981 7940 BB01 7BC0 7A80 BA41 BE01 7EC0 7F80 BF41 7DOO BDC1 BC81 7C40 B401 74C0 7580 B541 7700 B7C1 B681 7640 7200 B2C1 B381 7340 B101 71CO 7080 B041 X 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 VALOR 5000 90C1 9181 5140 9301 53CO 5280 9241 9601 56CO 5780 9741 5500 95C1 9481 5440 9C01 5CC0 5D80 9D41 5F00 9FC1 9E81 5E40 5A00 9AC1 9B81 5B40 9901 59CO 5880 9841 X 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 VALOR 8801 48C0 4980 8941 4B00 8BC1 8A81 4A40 4E00 8EC1 8F81 4F40 8D01 4DC0 4C80 8C41 4400 84C1 8581 4540 8701 47C0 4680 8641 8201 42C0 4380 8341 4100 81C1 8081 4040

Tabela 1: Tabela de operandos para clculo de CRC16 (valores calculados abaixo da linha horizontal)

22 CRC UFMG - Constantino Seixas Filho

Propriedades: Da observao de como Tab[X] calculado acima, podemos tirar algumas concluses. Estamos supondo que o valor inicial do CRC 0. a) Observe que Tab[X] = CRC (X) onde X um valor correspondendo a um byte: X7 .. X0. X varia de 0 a 255. b) CRC(0) = Tab[0] = 0, independente do polinmio, pois o resto da diviso de 0 por qualquer polinmio 0. c) CRC(0xFF) = Tab[0xFF] = T15 .. T0, onde Ti = XOR Nmero_Par_de_Termos (1) = 0, ou Ti = XOR Nmero_Impar_de_Termos (1) = 1. Observe que para o CRC16, CRC(0xFF) ter valor 1 apenas nos bits nas posies 6 e 14 onde o nmero de termos X j combinantes mpar. Portanto CRC16(0xFF) = 0x4040. d) CRC(not M) = CRC(M 0xFF) = CRC(M) CRC(0xFF), onde M uma mensagem de um byte. Imagine que conhecemos o CRC(M) = T15 ..T0. O CRC(not M) ter o mesmo valor do CRC de M para os bits em que o nmero de termos de Xi = Mi for par e ter o valor complementar ao de M onde o nmero de termos de Xi = Mi for mpar. A mscara que determina onde o nmero de bits combinantes de Xi para ou mpar exatamente o CRC(0xFF). Logo devemos trocar os bits do CRC(M) nestas posies onde CRC(0xFF) tem um bit igual a 1, ou seja basta realizar o ou exclusivo de CRC(M) com o CRC(0xFF). Exemplo: Seja calcular o CRC(254). CRC(254) = CRC(1) CRC(0xFF) = 0xC0C1 0x4040 = 0x8081. Esta propriedade implica que precisamos calcular apenas metade das posies da tabela, pois a outra metade determinada diretamente pela equao acima.

CRC UFMG - Constantino Seixas Filho

23

X 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

VALOR 0000 1189 2312 329B 4624 57AD 6536 74BF 8C49 9DC1 AF5A BED3 CA6C DBE5 E97E F8F7 1081 0108 3393 221A 56A5 472C 75B7 643E 9CC9 8D40 BFDB AE52 DAED CB64 F9FF E876

X 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

VALOR 2102 308B 0210 1399 6726 76AF 4434 55BD AD4A BCC3 8E58 9FD1 EB6E FAE7 C87C D9F5 3183 200A 1291 0318 77A7 662E 54B5 453C BDCD AC42 9ED9 8F50 FEEB EA66 D8FD C974

X 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

VALOR 4204 538D 6116 70F9 0420 15A9 2732 36BB CE4C DFC5 ED5E FCD7 8868 99E1 AB7A BAF3 5285 430C 7197 601E 14A1 0528 37B3 263A DECD CF44 FDDF EC56 98E9 8960 BBFB AA72

X 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

VALOR 6306 728F 4014 519D 2522 34AB 0630 17B9 EF4E FEC7 CC5C DDD5 A96A B8E3 8A78 9BF1 7387 620E 5095 411C 35A3 242A 16B1 0738 FFCF EE46 DCDD CD54 B8EB A862 9AF9 8B70

X 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159

VALOR 8408 9581 A71A B693 C22C D3A5 E13E F0B7 0840 19C9 2B52 3ADB 4E64 5FED 6D76 7CFF 9489 8500 B79B A612 D2AD C324 F1BF E036 18C1 0948 3BD3 2A5A 5EE5 4F6C 7DF7 6C7E

X 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191

VALOR A50A B483 8618 9791 E32E F2A7 C03C D1B5 2942 38CB 0A50 1BD9 6F66 7EEF 4C74 5DFD B58B A402 9699 8710 F3AF E226 D0DB C134 39C3 284A 1AD1 0B58 7FE7 6E6E 5CF5 4D7C

X 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223

VALOR C60C D785 E51E F497 8028 91A1 A33A B2B3 4A44 5BCD 6956 78DF 0C60 1DE9 2F72 3EFD D68D C704 F59F E416 90A9 8120 B3BB A232 5AC5 4B4C 79D7 685E 1CE1 0D68 3FF3 2E7A

X 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255

VALOR E70E F687 C41C D595 A12A B0A3 8238 93B1 6B46 7ACF 4854 59DD 2D62 3CEB 0E70 1FF9 F78F E606 D49D C514 B1AB A022 92B9 8330 7BC7 6A4E 58D5 495C 3DE3 2C6A 1EF1 0F78

Tabela 2: Tabela de operandos para clculo de CRC_CCITT O algoritmo final fica: Algoritmo final: Para todos os bytes da mensagem faa: 1. Calcule Xi = Low(CRC Mensagem). 2. Deslocar o CRC oito bits para a direita. 3. Realizar o ou exclusivo do CRC com o valor da tabela indexado por X. Esta tabela pode ser calculada para qualquer polinmio automaticamente atravs de um programa, que mostrado no exemplo completo que se segue:
// // // // // // Clculo de CRC-CCITT byte-wise Autor: Constantino Seixas Filho Data: 19/01/92

#include <stdio.h> #include <string.h> // ----------------------- Prottipos de funes ---------------------------unsigned MakeOper(int *);

24 CRC UFMG - Constantino Seixas Filho

unsigned CalcCRCBitwise(char *, int , unsigned ); unsigned CalcCRC(char *, int ); void GeraTabCrcCCITT(void); // --------------------------- Definies de Operandos Tpicos -----------------------------#define CRC_CCITT 0x8408 // ------------------------- Variveis Globais -----------------------------char tabela[]= "ola como vai tudo bem ?"; char string[]= "Segundo teste de CRC"; unsigned operando = CRC_CCITT; // p(x)= x16 + x12 + x5 + 1 unsigned tab[256]; // resultados parciais para calculo do crc byte-wise // -------------------------------------------------------------------------int px[17]= // 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 // x x x x x x x x x x x x x x x x x { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 }; // -------------------------------------------------------------------------void main() { int result; // teste da gerao da tabela auxiliar operando = MakeOper(px); printf("\noperando = %04x", operando); GeraTabCrcCCITT(); // teste do clculo do CRC result = CalcCRC(tabela, strlen(tabela)); printf("\nString 1: byte wise result = %04x", result); result = CalcCRC(string, strlen(string)); printf("\nString 2: byte wise result = %04x\n", result); result = CalcCRCBitwise(tabela, strlen(tabela), operando); printf("\nString 1: bit wise result = %04x", result); result = CalcCRCBitwise(string, strlen(string), operando); printf("\nString 2: bit wise result = %04x\n", result); } // main // -------------------------------------------------------------------------------------// Gera Operando ser utilizado nos algoritmos a partir do Polinmio P(x) // -------------------------------------------------------------------------------------unsigned MakeOper(int *px) { unsigned operando; operando = 0; // inverte ordem dos bits na palavra e despreza x16 for (int index=16; index > 0; --index) operando = (operando << 1) | (*(px+index)); return(operando); } // MakeOper // -------------------------------------------------------------------------// Gera tabela auxiliar para clculo de CRC-CCITT // -------------------------------------------------------------------------void GeraTabCrcCCITT(void) // gera tabela auxiliar para calculo deCRC CCITT // P(x) = x16 + x12 + x5 + 1

CRC UFMG - Constantino Seixas Filho

25

// // CRC_CCITT = 0x8408 // { static unsigned v[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; unsigned x1, x2, x3, x4, x5, x6, x7, x8; unsigned x; int i, cont; i = 0; for (x8=0; x8<2; x8++) for (x7=0; x7<2; x7++) for (x6=0; x6<2; x6++) for (x5=0; x5<2; x5++) for (x4=0; x4<2; x4++) for (x3=0; x3<2; x3++) for (x2=0; x2<2; x2++) for (x1=0; x1<2; x1++) { x = x8 ^ x7 ^ x6 ^ x5 ^ x4 ^ x3 ^ x2 ^ x1; v[15]= x8 ^ x4; v[14]= x7 ^ x3; v[13]= x6 ^ x2; v[12]= x5 ^ x1; v[11]= x4; v[10]= x8 ^ x4 ^ x3; v[ 9]= x7 ^ x3 ^ x2; v[ 8]= x6 ^ x2 ^ x1; v[ 7]= x5 ^ x1; v[ 6]= x4; v[ 5]= x3; v[ 4]= x2; v[ 3]= x8 ^ x4 ^ x1; v[ 2]= x7 ^ x3; v[ 1]= x6 ^ x2; v[ 0]= x5 ^ x1; tab[i]=0; for (cont=15; cont >= 0; --cont) tab[i] = (tab[i] << 1) | v[cont]; ++i; } // for } // GeraTabCrcCCITT // -------------------------------------------------------------------------------------// Gera tabela auxiliar para calculo de CRC, dado o polinmio divisor // -------------------------------------------------------------------------------------void GeraTabCRC(unsigned operando) { // deveria fazer um xor com o contedo inicial do CRC suposto igual a 0 for (int index = 0; index < 256; ++index) tab[index] = CalcCRCBitwise((char *) &index, 1, operando); } // GeraTabCRC // -------------------------------------------------------------------------// Calcula CRC bytewise // -------------------------------------------------------------------------unsigned CalcCRC(unsigned char *pch, int n_bytes) { register unsigned crc; unsigned index;

26 CRC UFMG - Constantino Seixas Filho

crc = 0; for (int cont=n_bytes; cont > 0; --cont) { index = (crc ^ *pch++) & 0x00FF; crc = (crc >> 8) ^ tab[index]; } return(crc); } // CalcCRC

// -------------------------------------------------------------------------// Calcula CRC bitwise // -------------------------------------------------------------------------unsigned CalcCRCBitwise(unsigned char *pch, int nBytes, unsigned Operando) { unsigned CRC; int bit0; CRC = 0; // Inicializa shift register para zero for (int cByte = nBytes; cByte >0; --cByte) { CRC ^= *pch++; for (int cBit=8; cBit >0; --cBit) { bit0 = 1 & CRC; CRC >>= 1; if (bit0 == 1) CRC ^= Operando; } } return (CRC); // CalcCRCBitwise

CRC-32
Este polinmio possui maior capacidade de deteco de erros que os polinmios de 16 bits, sendo usado na rede Ethernet, WinZip e PKZIP, etc. O polinmio utilizado : G(x)= x32+x26+x23+x22+x16+x12 +x11+x10+x8+x7+x5 +x4+x2+x1+1
static unsigned long crc32_table[256]; void gen_table(void) { unsigned long crc, poly; int i, j; poly = 0xEDB88320L; for (i = 0; i < 256; i++) { crc = i; for (j = 8; j > 0; j--) { if (crc & 1) crc = (crc >> 1) ^ poly; else crc >>= 1; } crc32_table[i] = crc; } CRC UFMG - Constantino Seixas Filho

27

unsigned long calc_crc32(unsigned char *pch, int nBytes) { register unsigned long crc; crc = 0xFFFFFFFF; for (int cByte = nBytes; cByte >0; --cByte) { crc = (crc>>8) ^ crc32_table[ (crc ^ *pch) & 0xFF]; return( crc^0xFFFFFFFF); }

Revertendo o CRC
Este um assunto academicamente interessante, principalmente se voc for um hacker : ) . Vamos discutir como alterar um conjunto de bytes em um string de bytes de modo que o CRC no seja alterado. Este problema pode ser formulado da seguinte maneira: Considere que uma mensagem possui N bytes e que o seu CRC calculado utilizando o polinmio de 16 bits P16 dado por: CRC16 (Mn) = K
Mensagem Original N k+x k+x-1 k+x-2 k+x-3 k k-1 4 3 2 1

bn CRC = K2 CRC = K

b4 b3 b2 b1 CRC = K1

Parte desta mensagem ser substituda por x novos bytes a partir da posio k:

Mensagem

Alterada N k+x k+x-1 k+x-2 *** *** k+2 k+1 k k-1 4 3 2 1

bn parte no modificada

mx y

mx-1 m 3 m2 x patch introduzido

m1

b4 b3 b2 b1 parte no modificada CRC = K1

Os ltimos bytes da modificao, posies mx-1 e mx contero dois bytes de ajuste que chamaremos de b e a respectivamente. O problema consiste em calcular a e b de tal forma que o CRC final da mensagem seja K.

28 CRC UFMG - Constantino Seixas Filho

Consideraes:

1. Evidentemente o CRC da posio 1 at a posio k- 1 o mesmo para as duas mensagens. Vamos cham-lo de K1. 2. A influncia dos bytes da posio k+x at a posio N ser a mesma nos dois casos. 3. Temos que fazer com que os CRCs ao chegar n aposio k+x+1 seja o mesmo nos dois strings. O valor inicial no registrador de CRC ao chegar na posio k ser K1. Ao calcular o CRC da mensagem modificada, ao chegar em k+x-3 teremos: CRC (b1..bk-1, m1..mx-2) = R = RH | RL Onde o smbolo | indica concatenao. RH o byte mais significativo no CRC e RL o byte menos significativo. Para conservar o valor do CRC devemos ter: R o x o y = K2 O operador o indica uma combinao segundo o algoritmo do clculo do CRC do valor do registrador quando acabamos de processar o patch com os bytes x e y em seqncia.
Como calcular x e y ?

Ns conhecemos R e K2. Segundo o algoritmo bytewise que deduzimos temos: Aps processar o byte x: Temp = (R >> 8) Tab[ (R x) & 0xFF] Temp = RH Tab[ (RL x)] Vamos supor que a posio apontada por RL b contenha o dado: bH | bL Temp = bH | RH bL Aps processar o byte y: CRC = (Temp >> 8) Tab[ (Temp y) & 0xFF] = K2 CRC = bH Tab[RH bL y] = K2 Vamos supor que a posio apontada por RL bL y contenha o dado: cH | cL CRC = cH | bH cL = K2 = K2H | K2L Logo pela equao acima ns deduzimos o valor de cH :
CRC UFMG - Constantino Seixas Filho

29

cH = K2H Sabendo este valor ns podemos procurar na tabela por uma entrada de ndice Ic tal que o seu bytes mais significativo seja o valor desejado (K2H ). Assim determinamos cL. Como bH cL = K2L temos que bH cL cL = K2LcL Logo da determinamos: bH = K2LcL Devemos novamente procurar na tabela por uma entrada de ndice Ib cujo byte mais significativo coincida com bH. Desta forma bL tambm fica determinado. J conhecemos b e c e tambm os ndices destas posies: Ib e Ic. RH bL y = Ic Logo y = bL RH Ic

RL x = Ib Logo x = RL Ib

30 CRC UFMG - Constantino Seixas Filho

Exerccios
1) Demonstre que a soma mdulo 2 equivalente subtrao mdulo 2. 2) Demonstre que a operao ou-exclusivo comutativa, associativa e tem elemento neutro. 3) Considere a seguinte mensagem: M = 1010010001 que ser transmitida MSB primeiro. 2 4 5 O polinmio gerador : P ( X ) = 1 + X + X + X a) Calcule o polinmio G(X) correspondente mensagem. b) Calcule o CRC. c) Calcule a mensagem final. d) Refaa os clculos considerando a transmisso do LSB primeiro. 4) Calcule primeiro. Calcule o CRC para a mensagem da questo 2 simulando passo a passo. Confira os resultados. 5) Explique a utilidade da funo MakeOper mostrada no programa de clculo de CRC. 6) Calcule a Tabela 2 para clculo do CRC bytewise para o CRC_CCITT. 7) Uma mensagem m=101110101000 foi transmitida em um canal de comunicao. esta mensagem foi anexado o CRC gerado pelo polinmio: P(X) = X3 + X2 + 1. Durante a transmisso ocorreu um erro que no foi detectado na recepo pelo algoritmo de CRC. Sugira um possvel polinmio representando o padro de bits do erro. 8) Questo do provo 2000: A camada de enlace de dados de uma estao de rede recebeu a seqncia de bits abaixo: 111001101110 Considerando que a tcnica de deteco de erros adotada a CRC (Cyclic Redundancy Check), e que o polinmio gerador utilizado : o circuito
2

para
4

gerar

P(X ) = 1 + X

+ X

+ X

o CRC relativo ao polinmio: . Considere a transmisso do LSB

G (x) = x 4 + x 3 + 1 ,
verifique se os dados sero aceitos pelo receptor como corretos. Justifique sua resposta (valor: 10,0 pontos)

CRC UFMG - Constantino Seixas Filho

31

9) Observe o circuito que se segue e responda:

Figura 9 Circuito de clculo de CRC Motorola MC8503 (segundo Peatman Microcomputer based design) a) Como a operao do circuito se Shift* = 1 ? b) Como a operao do circuito se Shift* = 0 ? c) Resuma como voc controlaria a operao deste circuito para calcular o CRC e logo aps apendar o valor do CRC ao final da mensagem. d) Na recepo antes dos 16 ltimos clocks serem aplicados e supondo que a transmisso foi correta, o valor do registador coincidir com o valor dos prximos 16 bits sendo recebidos. Explique porque a chegada dos ltimos 16 bits causa o preenchimento do registrador com 16 zeros. e) Qual o valor do operando para o nosso algoritmo de CRC que este circuito implementa ? f) Qual o valor do polinmio divisor ? 10) Existe diferena entre calcular o CRC-16 com o registro de CRC inicializado para 0 ou para 0xFFFF ? Voc capaz de prever este resultado ? Tente com uma mensagem qualquer e comente o resultado. 11) A mensagem M foi enviada por enviada por um canal de comunicao: M = The

quick brown fox jumps over the lazy dog

32 CRC UFMG - Constantino Seixas Filho

a) Calcule O CRC-16 desta mensagem. b) Voc deve trocar a expresso brown fox por mad cat. Depois deve calcular dois bytes extras para serem apendados ao final da mensagem de tal forma que o CRC no se altere. 12) Desenvolva uma calculadora de CRC didtica com as seguintes funcionalidades: a) O polinmio pode ser escolhido pelo usurio. Vrios polinmios clssicos dever estar pr cadastrados. b) A calculadora calcula o CRC de um string, bytes avulsos introduzidos na janela ou de bytes em um arquivo dado. c) Ela informa o tamanho da mensagem e o valor do CRC em hexadecimal. d) O valor inicial do registro de CRC pode ser escolhido pelo usurio. e) O simulador desenha o circuito emulador de diviso e mostra o seu contedo. f) O usurio pode processar a mensagem de uma nica vez ou byte a byte ou bit a bit. O sinal de realimentao do circuito (X0 = C0 M0) exibido a cada passo. Programe esta aplicao em Delphi. 13) A tabela 1 e 2 mostram os valores pr calculados do CRC de 0 a 255 que so usados no clculo do CRC bytewise. O que necessrio modificar nas tabelas se estamos calculando o CRC modificado, isto o CRC para um valor inicial do registrador de CRC de 0xFFFF ? 14) Calcule o CRC modificado de 0x75. 15) Calcule o CRC bytewise da mensagem: EC&A. No considere o caracter null ao final da mensagem. O primeiro caracter a ser processado o E.

CRC UFMG - Constantino Seixas Filho

33

Bibliografia
[Morse 86] [Mc Namara 88] Greg Morse. Calculating CRCs by bits and bytes. BYTE, September 1986, Pg 115..124. John McNamara. Technical Aspects of Data Communication, 3rd edition, 1988, Digital Equipment Corporation. Perez, Wizmer & Becker. Byte-wise CRC Calculations, IEEE Micro, June 1983. W.W.Peterson. Cyclic Codes for Error Detection, Proceedings of the IRE.January 1961 pp 228..235 Zvi Kohavi, Switching and finite automata theory, 2nd edition, TATA Mc Graw Hill, 1978.

[Perez 83] [Peterson 61] [Kohavi 78]

Sites a Visitar
CRC calculator www.efg2.com/Lab/Mathematics/CRC.htm

34 CRC UFMG - Constantino Seixas Filho