Você está na página 1de 43

Departamento de Cincias e Tecnologias da Informao

REDES DIGITAIS I

TRABALHO PRTICO I

Deteo e Correo de Erros

Curso: Informtica e Gesto de Empresas Grupo: rd1_tA-02

Nmero: 33940 Nmero: 35537 Nmero: 38425 Nmero: 35258

Nome: Catarina Maria Gonalves Martins Nome: Pedro Almeida Gama Torres Gamelas Nome: Ricardo Manuel Silva Pereira Nome: Stefanie de Sousa Pinheiro

Ano Letivo 2012/2013


Este relatrio foi escrito ao abrigo do novo Acordo Ortogrfico.

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

Declarao
Os alunos abaixo-assinados declaram que o trabalho a que se refere o relatrio que a seguir se apresenta original e foi realizado exclusivamente por si.

Nmero: _______

Nome: ____________________________________

Nmero: _______

Nome: ____________________________________

Nmero: _______

Nome: ____________________________________

Nmero: _______

Nome: ____________________________________

Data ____ / ____ / 2013

Pgina

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

ndice
1. Introduo .................................................................................................................................................... 4 1.1. Tcnicas Implementadas ..................................................................................................................... 4 Bit de Paridade ............................................................................................................................ 5 Expresses Tericas ........................................................................................................... 5 Expresses Prticas ............................................................................................................ 5

1.1.1.

1.1.1.1. 1.1.1.2. 1.1.2.

CRC com polinmio gerador de grau 4, G23(x) ........................................................................... 5 Expresses Tericas ........................................................................................................... 6 Expresses Prticas ............................................................................................................ 6

1.1.2.1. 1.1.2.2. 1.1.3.

Cdigo de Hamming .................................................................................................................... 6 Expresses Tericas ........................................................................................................... 7 Expresses Prticas ............................................................................................................ 7

1.1.3.1. 1.1.3.2. 2.

Implementao ............................................................................................................................................ 8 2.1. 2.2. 2.3. Bit de Paridade .................................................................................................................................... 8 CRC com polinmio gerador de grau 4, G23(x) ................................................................................... 9 Cdigo de Hamming .......................................................................................................................... 11

3.

Resultados da Simulao .......................................................................................................................... 16 3.1. 3.2. 3.3. Bit de Paridade .................................................................................................................................. 16 CRC com polinmio gerador de grau 4, G23(x) ................................................................................ 19 Cdigo de Hamming .......................................................................................................................... 22

4. 5.

Concluses ................................................................................................................................................ 26 Anexos ....................................................................................................................................................... 27

Pgina

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

1. Introduo
Este trabalho destinado unidade curricular Redes Digitais I: Fundamentos, sob orientao dos docentes Paulo Nunes, Rui Lopes e Lus Cancela. Tem como principal objetivo a implementao em linguagem Java de tcnicas de deteo e correo de erros utilizadas nas redes de computadores e os seus respectivos testes, atravs de dois modos de funcionamento: Modo de Demonstrao: pretende ilustrar o funcionamento de cada uma das tcnicas de deteo e correo de erros. Modo de Simulao: com vista a testar e gerar estatsticas de desempenho de cada uma das tcnicas para diferentes probabilidades de erro de bit e tamanho de trama. Ser feita a simulao de uma transmisso de dados de um emissor para um recetor. Estes dados sero alvo do efeito de um canal ruidoso que ir gerar erros no sinal, ou seja, consiste na simulao de erros introduzidos pelo meio numa transmisso, alterando a trama segundo um determinado padro de erros. A trama a unidade de dados referente ao nvel de ligao. acrescentado um cabealho e um rodap de forma a limitar os dados. 1. Os dados so gerados no emissor, sendo o seu tamanho de 4 ou 11 bits. 2. Depois de escolhido o algoritmo de deteo e correo de erros so aplicadas as regras a ele referentes sobre os dados, como por exemplo, a adio de bits redundantes. 3. Esses dados passaro pelo canal ruidoso, cujo padro de erros ser aleatrio ou introduzido de forma manual. 4. Aquando a receo dos dados por parte do recetor, este processa-a conforme a tcnica implementada. Neste passo detetam-se os erros e, se aplicvel, corrigem-se. As funcionalidades do programa que ir ser mostrado parcialmente ao longo deste relatrio (e integralmente em anexo) prendem-se com a simulao dos seguintes aspetos: Gerao de sequncias de bits de tamanho varivel; Comportamento de um canal ruidoso, parametrizado atravs da probabilidade de erro de bit.

1.1. Tcnicas Implementadas


Existem duas estratgias bsicas para tratar os erros. A primeira incluir informaes redundantes suficientes em cada bloco de dados enviado e, assim, o recetor capaz de deduzir quais devem ter sido os dados transmitidos. Utiliza cdigos de correo de erros. A segunda incluir uma redundncia de dados suficiente apenas para permitir que o recetor deduza que houve um erro, mas no identifica qual e pede uma retransmisso. Utiliza cdigos de deteo de erros. Referem-se, portanto, a metodologias de gerao de bits redundantes a adicionar aos dados para verificar a existncia de erros aps o envio e, caso necessrio, tentar a correo dos mesmos. Os algoritmos de deteo/correo de erros implementados sero baseados nas seguintes tcnicas: 4

Pgina

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

1.1.1. Bit de Paridade


Esta a tcnica mais utilizada e atua ao nvel do bit, no entanto, no h correo de erros, apenas deteo. Neste trabalho -nos indicado que a paridade par. Baseia-se na contagem de 1 na sequncia de bits da trama. Se essa contagem resultar num nmero par, acrescentado o valor 0 no final da trama, caso contrrio, acrescenta-se um 1. Por exemplo, dado 1001. Temos dois 1 e, sendo par, trama seria adicionado um 0, ficando 10010. A deteo de erros por parte do recetor feita caso a trama recebida tenha um nmero de 1 mpar, uma vez que o bit redundante assegura sempre a paridade.

1.1.1.1.

Expresses Tericas Seja k um nmero mpar, n o tamanho da trama e Pb a probabilidade de erro de bit.
= ( ) = (1 ) ( , ) = = 1
(1 ) 1 (1 ) (1 ) 1 (1 )

( , )

1.1.1.2.

Expresses Prticas
( ) = ( ) =

( ) =

1.1.2. CRC com polinmio gerador de grau 4, G23(x)


O Cyclic Redundancy Code baseia-se na associao entre sequncias binrias e polinmios. Consiste no clculo dos bits redundantes. Consideremos uma palavra M = 1101. O seu polinmio ser: ( ) = 1 3 + 1 2 + 0 + 1 = 3 + 2 + 1

O FCS (Frame Check Sequence) uma sequncia de bits gerada pelo emissor que ser agregada a um polinmio M, originando uma trama que tem se ser exatamente divisvel por uma determinada sequncia de bits, denominada polinmio gerador G. Neste trabalho, o polinmio gerador :
Pgina

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

O recetor divide a trama pela mesma sequncia de bits e se o resto for zero assume que no h erros ou que no foram detetados. ( ) ( ) = ( ) 1.1.2.1. Expresses Tericas Seja k um nmero mpar, n o tamanho da trama e Pb a probabilidade de erro de bit.
= ( ) = (1 ) ( , ) = 1

( ) = 4 + 2 + + 1

( , ) =

2r 1 (1 )

2 1 (1 )

1.1.2.2.

Expresses Prticas
( ) = ( ) =

( ) =

V =

1.1.3. Cdigo de Hamming


Dadas duas palavras de cdigo possvel determinar quantos bits correspondentes apresentam diferenas, efetuando uma operao entre as duas palavras de cdigo e contar o nmero de bits a 1 no resultado.

10001001 10110001 00111000

O nmero de posies de bits em que duas palavras de cdigo diferem entre si chamado distncia de Hamming, sendo esse o nmero de bits que se tem que alterar para passar de uma palavra do cdigo para outra. Os princpios fundamentais para a deteo e correo de erros com o Cdigo de Hamming so os seguintes: Para enviar m bits de mensagem devemos transmitir n bits tal que n = m + r, onde r bits so redundantes, isto , no teis.
Pgina

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

O nmero de palavras possveis de serem recebidas -nos dado por 2 . O nmero de palavras possveis de serem transmitidas -nos dado por 2 , valor que tambm nos d o nmero de palavras vlidos num cdigo. Para sabermos o nmero de bits redundantes necessrios a expresso aproximada r log2 n + 1.
m

1.1.3.1.

Expresses Tericas Seja k um nmero mpar, n o tamanho da trama e Pb a probabilidade de erro de bit.
= = ( ) = (1 ) ( , )
1 1 (1 )1 + 2 2 (1 )2 1 (1 )

( , ) = 1

1 1 (1 )1 + 2 2 (1 )2 1 (1 )

1.1.3.2.

Expresses Prticas
( ) = ( ) =

( ) =

( ) = V =

Pgina

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

2. Implementao
Este trabalho foi desenvolvido em linguagem Java. O programa inicia-se com o seguinte output:
Trabalho pratico 1: Deteccao e correcao de erros

Escolha do modo de funcionamento: 1) Modo de Demonstracao 2) Modo de Simulacao

O utilizador dever escolher entre a opo 1) Modo de Demonstrao ou a opo 2) Modo de Simulao. Escolhendo a primeira opo, o percurso ser o seguinte:

Escolha da tecnica de deteccao e correccao de erros: 1) Bit Paridade 2) CRC 23 3) Codigo de Hamming

Utilizar tramas com: 1) 4 bits de dados 2) 11 bits de dados

Escolha do modo de geracao de dados: 1) Manual 2) Automatico

2.1.

Bit de Paridade
A implementao desta tcnica comea no emissor. Aps o tamanho dos dados estar definido, ou seja, 4 ou 11 bits, gerada uma trama atravs da tcnica Bit de Paridade, explicada atrs neste relatrio. Foi criada uma trama de tamanho igual ao nmero de dados mais um, sendo este ltimo bit o de paridade. O valor da paridade dos dados foi ento calculado: caso o valor calculado for par, o ltimo bit da trama a enviar ser 0, caso contrrio ser 1. O recetor comea por calcular a paridade dos dados e no deteta erros em duas situaes: quando a paridade par e o ltimo bit 0 ou quando a paridade impar e o ltimo bit 1. Nos casos em que a paridade do padro de erros impar e h mais do que 1 bit errado, os erros da trama no so detetados, apesar de existirem erros. Emissor:

private void gerarTramaBitParidade(int numeroBitsDados) { tramaAEnviar = new int[numeroBitsDados+1]; int valorBitParidadeAux = 0; for (int i = 0; i < dados.length; i++) { if (dados[i] == 1) valorBitParidadeAux++; tramaAEnviar[i] = dados[i]; } if (valorBitParidadeAux % 2 == 1) {

Pgina

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

tramaAEnviar[numeroBitsDados] = 1; }else { tramaAEnviar[numeroBitsDados] = 0; } }

Recetor:
private void procuraErroBitDeParidade(int tamanhoTramaRecebida, int numeroErros) { int paridade = 0; int bitsUteis = tamanhoTramaRecebida - 1; int bitDeParidade = tramaRecebida[tamanhoTramaRecebida-1]; for (int i = 0; i < bitsUteis; i++) { if (tramaRecebida[i] == 1) paridade++; } if (paridade % 2==0 && bitDeParidade==0 || paridade % 2==1 && bitDeParidade==1) { temErro = false; if (numeroErros > 0) { tramas_Com_Erros_Nao_Detectados++; } }else { temErro = true; tramas_Com_Erros_Detectados++; } }

2.2.

CRC com polinmio gerador de grau 4, G23(x)


Na implementao desta tcnica, comeamos por definir o tamanho da trama a enviar, sendo este igual ao nmero de bits de dados mais quatro bits de redundncia. Os bits de dados so transportados para a trama a enviar, enquanto que os bits de redundncia so inicializados a 0 e adicionados no final da trama anterior. De seguida, definimos 4 variveis temporrias (i0, i1, i2 e i3), permitindo assim tornar o sistema assncrono, isto , s se atualiza os valores dos bits de redundncia no final de cada ciclo. O esquema CRC do polinmio gerador ( ) = 4 + 2 + + 1 em que nos baseamos para a implementao desta tcnica foi o seguinte:

O clculo dos valores dos bits de redundncia efetuado atravs de expresses prprias como podemos ver nos excertos de cdigo abaixo apresentados. No incio de cada ciclo

Pgina

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

comeamos por calcular o valor das variveis temporrias da seguinte forma, em que o ^ simboliza o em Java:
i0 = tramaAEnviar[i] ^ c3; i1 = c0 ^ c3; i2 = c1 ^ c3; i3 = c2;

Aps o trmino da primeira ronda de operaes, passamos atualizao do valor dos check bits C0, C1, C2 e C3, aos quais sero atribudos os valores de i0, i1, i2 e i3 respetivamente. Na parte do recetor, a metodologia praticada semelhante mas desta vez processamos a trama recebida atravs do canal ruidoso. Calculamos novamente os valores de C0, C1, C2 e C3 e verificamos o seu valor. Caso um destes seja diferente de zero, ele detecta erro, caso contrrio, no detecta apesar de poderem existir erros.

Emissor:
private void gerarTramaCRC23(int numeroBitsDados) { tramaAEnviar = new int[numeroBitsDados + 4]; for (int i = 0; i < dados.length; i++) { tramaAEnviar[i] = dados[i]; } for (int i = 4; i < tramaAEnviar.length; i++) { tramaAEnviar[i] = 0; } int i0 = 0, i1 = 0, i2 = 0, i3 = 0, c0 = 0, c1 = 0, c2 = 0, c3 = 0; for (int i = 0; i < tramaAEnviar.length; i++) { i0 = tramaAEnviar[i] ^ c3; i1 = c0 ^ c3; i2 = c1 ^ c3; i3 = c2; c0 = i0; c1 = i1; c2 = i2; c3 = i3; }

System.arraycopy(dados, 0, tramaAEnviar, 0, numeroBitsDados); tramaAEnviar[numeroBitsDados] = c3; tramaAEnviar[numeroBitsDados + 1] = c2; tramaAEnviar[numeroBitsDados + 2] = c1; tramaAEnviar[numeroBitsDados + 3] = c0; }

Recetor:
private void procuraErroCRC23(int tamanhoTramaRecebida, int numeroErros) { int i0 = 0, i1 = 0, i2 = 0, i3 = 0, c0 = 0, c1 = 0, c2 = 0, c3 = 0; for (int i = 0; i < tamanhoTramaRecebida; i++) {

Pgina

10

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

i0 = tramaRecebida[i] ^ c3; i1 = c0 ^ c3; i2 = c1 ^ c3; i3 = c2; c0 = i0; c1 = i1; c2 = i2; c3 = i3; } if (c0 == 0 && c1 == 0 && c2 == 0 && c3 == 0) { temErro=false; if (numeroErros > 0) { tramas_Com_Erros_Nao_Detectados++; } }else { temErro=true; tramas_Com_Erros_Detectados++; } }

2.3.

Cdigo de Hamming
O cdigo de Hamming consiste em encontrar bits de paridade, para gerar a informao redundante, que ir compor a trama a ser enviada pelo emissor. Os bits de paridade encontram-se nas posies que sejam potncias de 2 (qual o n para o qual 2 = 3? No existe. Logo na posio 3 no existe bit de paridade).
n

2n = 1 n = 0,00 P1

2n = 2 n = 1,00 P2

2n = 3 n = 1,58 X3

2n = 4 n = 2,00 P4

2n = 5 n = 2,32 X5

2n = 6 n = 2,58 X6

2n = 7 n = 2,80 X7

2n = 8 n = 3,00 P8

2n = 9 n = 3,16 X9

2n = 10 n = 3,32 X10

2n = 11 n = 3,45 X11

Depois devemos escrever as expresses dos bits de paridade, comeando por escrever os n em binrio. Os que estiverem a 1 iro dar origem a um elemento Pi. As expresses que se podem retirar da tabela do lado direito so as seguintes:
P1 = X11 X9 X7 X5 X3 X1 P2 = X11 X10 X7 X6 X3 X2 P4 = X7 X6 X5 X4 P8 = X11 X10 X9 X4 1 2 3 4 5 6 7 8 9 10

P8 0 0 0 0 0 0 0 1 1 1 1

P4 0 0 0 1 1 1 1 0 0 0 0

P2 0 1 1 0 0 1 1 0 0 1 1

P1 1 0 1 0 1 0 1 0 1 0 1

Depois de retiradas estas expresses, a trama envia-

11

Pgina

11

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

da. Para sabermos o valor do bit de verificao (check bits), faz-se um XOR das expresses anteriores com o respetivo bit de paridade. Assim:
C1 = X11 X9 X7 X5 X3 X1 P1 C2 = X11 X10 X7 X6 X3 X2 P2 C4 = X7 X6 X5 X4 P4 C8 = X11 X10 X9 X4 P8

Se C1, C2, C4 e C8 forem iguais a 0, indica que no existem erros ou os erros no foram detetados. Caso haja pelo menos um que seja diferente de 0 significa que foram detetados erros. O cdigo de Hamming deteta de certeza d-1 erros e corrige simboliza a distncia de Hamming.
d-1 2

erros, tal que d

Em relao implementao propriamente dita, criou-se uma trama cujo nmero de bits igual ao nmero de bits dos dados mais os nmeros de bits de redundncia. Caso o nmero de bits de dados seja 4 ou 11, o nmero de bits de redundncia sero 3 ou 4, respetivamente. Os passos seguintes esto relacionados com a explicao dada anteriormente. No que toca ao lado do recetor, caso a trama seja de tamanho igual a 7 ou 15, o nmero de checkbits ser 3 ou 4 respetivamente. Se algum dos checkbits for diferente de 0, ento o recetor deteta os erros. Emissor:
private void gerarTramaHamming(int numeroBitsDados) { switch (numeroBitsDados) { case 4: gerarTramaHamming4bitsUteis(numeroBitsDados); break; case 11: gerarTramaHamming11bitsUteis(numeroBitsDados); break; } } private void gerarTramaHamming4bitsUteis(int numeroBitsDados) { tramaAEnviar = new int[numeroBitsDados+3]; int indice4DadosAux = 0; for (int i = 0; i < tramaAEnviar.length; i++) { if (i == 2 || i == 4 || i ==5 || i ==6) { tramaAEnviar[i] = dados[indice4DadosAux]; indice4DadosAux++; } } tramaAEnviar[0]= tramaAEnviar[2] ^ tramaAEnviar[4] ^ tramaAEnviar[6]; tramaAEnviar[1]= tramaAEnviar[2] ^ tramaAEnviar[5] ^ tramaAEnviar[6]; tramaAEnviar[3]= tramaAEnviar[4] ^ tramaAEnviar[5] ^ tramaAEnviar[6]; }

Pgina

12

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

private void gerarTramaHamming11bitsUteis(int numeroBitsDados) { tramaAEnviar = new int[numeroBitsDados+4]; int indice11DadosAux = 0; for (int i = 0; i < tramaAEnviar.length; i++) { if (i==2||i==4 ||i==5||i==6||i==8||i==9||i==10||i==11||i==12||i==13||i==14) { tramaAEnviar[i] = dados[indice11DadosAux]; indice11DadosAux++; } } tramaAEnviar[0]= tramaAEnviar[2] ^ tramaAEnviar[4] ^ tramaAEnviar[6] ^ tramaAEnviar[8] ^ tramaAEnviar[10] ^ tramaAEnviar[12] ^ tramaAEnviar[14]; tramaAEnviar[1]= tramaAEnviar[2] ^ tramaAEnviar[5] ^ tramaAEnviar[6] ^ tramaAEnviar[9] ^ tramaAEnviar[10] ^ tramaAEnviar[13] ^ tramaAEnviar[14]; tramaAEnviar[3]= tramaAEnviar[4] ^ tramaAEnviar[5] ^ tramaAEnviar[6] ^ tramaAEnviar[11] ^ tramaAEnviar[12] ^ tramaAEnviar[13] ^ tramaAEnviar[14]; tramaAEnviar[7]= tramaAEnviar[8] ^ tramaAEnviar[9] ^ tramaAEnviar[10] ^ tramaAEnviar[11] ^ tramaAEnviar[12] ^ tramaAEnviar[13] ^ tramaAEnviar[14];

} Recetor:
private void procuraErroHamming(int tamanhoTramaRecebida, int numeroErros) { switch (tamanhoTramaRecebida) { case 7: procuraErroHamming7(tamanhoTramaRecebida, numeroErros); break; case 15: procuraErroHamming15(tamanhoTramaRecebida, numeroErros); break; } } private void procuraErroHamming7(int tamanhoTramaRecebida, int numeroErros) { int c0 = tramaRecebida[2]^tramaRecebida[4]^tramaRecebida[6]^tramaRecebida[0]; int c1 = tramaRecebida[2]^tramaRecebida[5]^tramaRecebida[6]^tramaRecebida[1]; int c3 = tramaRecebida[4]^tramaRecebida[5]^tramaRecebida[6]^tramaRecebida[3]; int[] checkBits = {c0, c1, c3}; for (int i = 0; i < checkBits.length; i++) { if (checkBits[i] == 1) { tramas_Com_Erros_Detectados++; temErro = true; break; } } if (numeroErros > 0 && !temErro) { tramas_Com_Erros_Nao_Detectados++; } if (temErro) corrigeErroHamming7(checkBits, numeroErros); Pgina

13

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

} private void corrigeErroHamming7(int[] checkBits, int numeroErros) { int bitErrado = 0; if (checkBits[0] == 1) { bitErrado+=1; } if (checkBits[1] == 1) { bitErrado+=2; } if (checkBits[2] == 1) { bitErrado+=4; } corrigeErroHamming(bitErrado, numeroErros); } private void procuraErroHamming15(int tamanhoTramaRecebida, int numeroErros) { int c0 = tramaRecebida[2] ^ tramaRecebida[4] ^ tramaRecebida[6] ^ tramaRecebida[8] ^ tramaRecebida[10] ^ tramaRecebida[12] ^ tramaRecebida[14] ^ tramaRecebida[0]; int c1 = tramaRecebida[2] ^ tramaRecebida[5] ^ tramaRecebida[6] ^ tramaRecebida[9] ^ tramaRecebida[10] ^ tramaRecebida[13] ^ tramaRecebida[14] ^ tramaRecebida[1]; int c3 = tramaRecebida[4] ^ tramaRecebida[5] ^ tramaRecebida[6] ^ tramaRecebida[11] ^ tramaRecebida[12] ^ tramaRecebida[13] ^ tramaRecebida[14] ^ tramaRecebida[3]; int c7 = tramaRecebida[8] ^ tramaRecebida[9] ^ tramaRecebida[10] ^ tramaRecebida[11] ^ tramaRecebida[12] ^ tramaRecebida[13] ^ tramaRecebida[14] ^ tramaRecebida[7]; int[] checkBits = {c0, c1, c3, c7}; for (int i = 0; i < checkBits.length; i++) { if (checkBits[i] == 1) { tramas_Com_Erros_Detectados++; temErro = true; break; } } if (numeroErros > 0 && !temErro) { tramas_Com_Erros_Nao_Detectados++; } if (temErro) corrigeErroHamming15(checkBits, numeroErros); } private void corrigeErroHamming15(int[] checkBits, int numeroErros) { int bitErrado = 0; if (checkBits[0] == 1) { bitErrado+=1; } if (checkBits[1] == 1) { bitErrado+=2; } if (checkBits[2] == 1) { Pgina

14

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

bitErrado+=4; } if (checkBits[3] == 1) { bitErrado+=8; } corrigeErroHamming(bitErrado, numeroErros); } private void corrigeErroHamming(int bitErrado, int numeroErros) { tramaCorrigida = new int[tramaRecebida.length]; for (int i = 0; i < tramaCorrigida.length; i++) { tramaCorrigida[i] = tramaRecebida[i]; if (i == bitErrado-1){ tramaCorrigida[i] = tramaRecebida[i] ^ 1; temCorrecao = true; } } if (numeroErros == 1) { tramas_Com_Erros_Detectados_E_Corrigidos++; } }

Pgina

15

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

3. Resultados da Simulao
3.1. Bit de Paridade
Uma vez que esta tcnica apenas permite a deteo de dados e no a sua correo, apenas poderemos apresentar grficos referentes deteo.

3.1.1.

4 Bits
No grfico abaixo, que nos relacionam o clculo da probabilidade de transmisso sem erros prtico com a probabilidade de transmisso sem erros terico, podemos verificar que no se denota grandes diferenas de valores pois esto praticamente sobrepostas. Com uma probabilidade de erro de 10 , a probabilidade de transmisso sem erros est muito perto dos 100%, havendo uma descida entre a probabilidade de erro igual a 0,01 e a 0,1. Com probabilidade de erro igual a 50%, a probabilidade de transmisso sem erros, tanto na prtica como na teoria, muito prxima de 0. Os valores precisos podero ser consultados nas tabelas em anexo.
-6

No grfico com o ttulo Valor esperado de bits errados na trama, representado de seguida, podemos verificar que o nmero de bits errados aumenta com o aumento da probabilidade de erro, nomeadamente entre a probabilidade 0,01 e a probabilidade 0,1. Com uma probabilidade de erro de 0,5, existe um valor esperado de bits errados na trama de 2,5.

Pgina

16

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

A probabilidade de no serem detetados erros dado que a trama sofreu erros em mensagem de 4 bits utilizando a tcnica do bit de paridade cresce de uma maneira mais exponencial a partir da probabilidade de erro igual a 0,01. Com uma probabilidade de erro de 0,5, aproximadamente 50% das tramas com erros no foram detetadas.

3.1.2.

11 Bits
semelhana do que se passou com os 4 bits, nesta simulao com 11 bits, as probabilidades de transmisso sem erros prtica e a probabilidade de transmisso sem erros terica veem os seus valores praticamente iguais medida que a probabilidade de erro aumenta. Mais uma vez se verifica uma grande descida de ambas as probabilidades de transmisso entre as probabilidades de erro 0,01 e 0,1.

Pgina

17

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

O valor esperado de bits errados na trama transmitida aumenta com o aumento da probabilidade de erro. At a uma probabilidade de erro de 0,01, esperam-se cerca de 0 bits errados na trama. A partir de 0,01, o valor sobe at a 6 bits errados em 11 bits com uma probabilidade de erro de 50%.

A probabilidade de os erros no serem detetados por est tcnica quando uma trama sofreu erros semelhante s tramas com 4 bits, sendo que com uma probabilidade de erro de 0,5, 50% dos erros no so detectados.

Pgina

18

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

3.2.

CRC com polinmio gerador de grau 4, G23(x) 4 Bits


Com a anlise deste grfico podemos concluir que a tcnica CRC deteta erros com a mxima eficcia para probabilidades de bit inferiores a 0,1. Existe uma nfima probabilidade do algoritmo no detetar o erro antes da probabilidade de bit 0,001.

3.2.1.

No grfico seguinte o valor esperado de bits errados numa trama muito reduzido para as probabilidades de erro de bit baixas. No entanto esse valor sobe exponencialmente a partir da probabilidade de erro de bit 0,1.

Pgina

19

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

Com base no grfico seguinte confirma-se que o algoritmo no falha na deteo de erros para probabilidades de erro de bit muito reduzidas. Do mesmo modo verifica-se as mesmas tendncias para valores de probabilidades mais elevadas mas com deteo de erros muito reduzidas.

3.2.2.

11 Bits
Como se pode ver atraves da observaao dos graficos do CRC de 4 bits, este grafico bastante semelhante tendo tambem uma eficacia muito elevada para probabilidades de bit inferiores a 0,1. Existem tambem uma infima probabilidade de o algoritmo no detetar o erro antes da probabilidade de bit 0,001.

Pgina

20

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

No grfico valor esperado de bits errados na trama para o CRC de 11 bits podemos observar que o valor esperado de bits errados numa trama muito reduzido para as probabilidades de erro de bit baixas mas no entanto esse valor sobe exponencialmente a partir da probabilidade de erro de bit 0,1.

No grfico seguinte confirma-se que o algoritmo no falha na deteo de erros para probabilidades de erro de bit muito reduzidas. Do mesmo modo verifica-se as mesmas tendncias para valores de probabilidades mais elevadas mas com deteo de erros muito reduzidas nunca alcanando valores superiores a 6,5%.

Pgina

21

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

3.3.

Cdigo de Hamming 4 Bits


Tal como se verificou em outras tcnicas, as probabilidades de transmisso sem erros, tericas e prticas, acompanham-se ao longo do aumento da probabilidade de erro. At ao valor da probabilidade de erro de 0,001, a probabilidade de transmisso sem erros igual a 1. A partir desse valor, a probabilidade de transmisso sem erros comea a diminuir, at que chega a 0 com uma probabilidade de erro de 0,5.

3.3.1.

No envio de tramas de 4 bits, utilizando a tcnica do cdigo de Hamming para a deteo de erros, apercebemo-nos que a partir da probabilidade de erro 0,01, o valor esperado de bits errados na trama aumenta exponencialmente. Com uma probabilidade de erro de 0,5, o valor esperado de bits errados na trama de 3,5.

Pgina

22

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

Sendo esta a primeira tcnica que implementa correo de erros, podemos concluir que a correo dos mesmos 100% correta at uma probabilidade de erros igual a 0,1. Depois desta probabilidade, a percentagem de correo correta comea a diminuir. Com uma probabilidade de erro de 0,5, a probabilidade de correo correta praticamente nula, isto , perto de 0%.

Nesta tcnica a probabilidade de no serem detetados erros dado que a trama sofreu erros assume o valor de 0% at uma probabilidade de erro de 0,01. A partir desse valor, a probabilidade cresce exponencialmente. Com uma probabilidade de erro de 0,5, a probabilidade de no detetar os erros mesmo que a trama sofra erros cerca de 12%.

Pgina

23

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

3.3.2.

11 Bits
Neste grfico podemos verificar que para valores muito baixos de probabilidade de errar um bit a tcnica de Hamming consegue detectar com grande eficcia erros na transmisso, pois no devem ocorrer mais do que dois erros para estas probabilidades. Isto deve-se ao facto da distncia de Hamming ser 3 para esta tcnica, o que traduz a deteco at 2 erros. Posteriormente o numero de erros poder ser elevado o faz com que este mtodo no detecte todos os erros.

No grfico seguinte pode-se concluir que o valor esperado de bits errados na trama muito reduzido para probabilidades muito baixas. Com a evoluo das probabilidades esse valor de bits errados aumenta exponencialmente.

Pgina

24

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

Neste grafico podemos concluir que a probabilidade de correcao de erros muito elevada para probabilidades baixas pois o numero de erros tambem muito reduzido. Essa probabilidade de correcao correcta comea a diminuir a partir da probabilidade de erro 1% chegando a alcanar o valor de 0% na probabilidade de erro de 50%

Neste grfico a probabilidade de serem detectados erros dado que sofreu erros inexistente para probabilidades de erro inferiores a 0,01. A partir deste valor essa probabilidade vai aumentando at valores prximos de 6,5%.

Pgina

25

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

4. Concluses
Observando as anlises efectuadas aos grficos obtidos podemos concluir que qualquer uma das trs tcnicas de codificao/descodificao de tramas apresenta vantagens e desvantagens dependendo dos diferentes tipos de meios de transmisso, e que numa situao de ausncia de erros qualquer uma delas seria prefervel. Analisando cada um dos trs algoritmos individualmente observamos que o algoritmo de CRC se destaca pela sua particular eficincia na deteco de erros, em contrapartida a sua implementao de grande complexidade, logo no se justifica a sua aplicao num ambiente onde a probabilidade de ocorrncia de erros seja muito reduzida. No algoritmo de Bit de paridade por sua vez verificamos que apesar de ser uma tcnica muito fcil de implementar a que tem menor probabilidade de detectar erros. No entanto, num meio onde ocorram poucos erros, ou num meio onde ocorra um nmero mpar de erros esta tcnica muito eficaz pois vai alterar a paridade da trama e garantidamente detectar o/os erro/s. Por fim o algoritmo de Hamming mostrou ser o mais eficiente, pois para alm de detectar os erros tambm os corrige, contudo s detecta garantidamente at 2 erros, e s corrige (ou tenta corrigir) apenas um erro. Concluindo, como foi dito anteriormente, todos os algoritmos apresentam vantagens e desvantagens dependendo do meio de transmisso onde estejam. No entanto se tivssemos que obrigatoriamente optar por um, tendo em conta os resultados obtidos durante este trabalho, optaramos pelo algoritmo de CRC que apesar de no corrigir os erros garante a sua total deteco.

Pgina

26

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

5. Anexos
Em anexo apresentaremos as tabelas que nos serviram de base para o desenvolvimento e elaborao do clculo e esboo do grfico das probabilidades apresentados neste relatrio. Tambm ser apresentado mais frente o cdigo integral em Java.

Hamming 11 bits
Probabilidade de Erro 0.0001% 0.001% 0.01% 0.1% 1.0% 10.0% 12.5% 25.0% 50.0% Probabilidade de Erro 0,000001 0,00001 0,0001 0,001 0,01 0,1 0,125 0,25 0,5 Enviadas 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 Com Erros 114 1466 14897 148675 1398066 7940705 8650723 9865856 9999707 Sem Erros 9999886 9998534 9985103 9851325 8601934 2059295 1349277 134144 293 Erros Detetados 114 1466 14897 148674 1397717 7801659 8436263 9337992 9373611

Erros no Detetados 0 0 0 1 349 139046 214460 527864 626096

Erros Corrigidos 114 1466 14889 147649 1301698 3429001 2891703 668853 4612

Prob. Tx s/erros - Pratico 0,9999886 0,9998534 0,9985103 0,9851325 0,8601934 0,2059295 0,1349277 0,0134144 0,0000293

Prob. Tx s/erros - Terico 0,9999850 0,9998500 0,9985010 0,9851045 0,8600584 0,2058911 0,1349338 0,0133635 0,0000305

Valor esperado de bits errados na trama 0,0000114 0,0001466 0,0014905 0,0149708 0,1498781 1,5003875 1,8747892 3,7494390 7,5005853

Probabilidade de correo correta 100% 100% 100% 99,31% 93,11% 43,18% 33,43% 6,78% 0,05%

P (No serem detetados erros | sofreu erros) 0,00% 0,00% 0,00%

Pgina

27

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

0,00% 0% 2% 2,48% 5,35% 6%

Hamming 4bits
Probabilidade de Erro 0.0001% 0.001% 0.01% 0.1% 1.0% 10.0% 12.5% 25.0% 50.0% Erros no Detetados 0 0 0 0 69 51333 91413 462711 1172591 Probabilidade de Erro 0,000001 0,00001 0,0001 0,001 0,01 0,1 0,125 0,25 0,5 Erros Corrigidos 86 731 7068 69503 659204 3718312 3925459 3112999 546514 Enviadas 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 Com Erros 86 731 7068 69702 679271 5216418 6073693 8665570 9921660 Sem Erros 9999914 9999269 9992932 9930298 9320729 4783582 3926307 1334430 78340 Erros Detetados 86 731 7068 69702 679202 5165085 5982280 8202859 8749069

Prob. Tx s/erros - Pratico 0,9999914 0,9999269 0,9992932 0,9930298 0,9320729 0,4783582 0,3926307 0,1334430 0,0078340

Prob. Tx s/erros - Terico 0,9999930 0,9999300 0,9993002 0,9930210 0,9320653 0,4782969 0,3926959 0,1334839 0,0078125

Valor esperado de bits errados na trama 0,0000086 0,0000731 0,0007068 0,0069901 0,0699668 0,7000836 0,8753543 1,7504045 3,4997903

Probabilidade de correo correta 100% 100% 100% 100% 97% 71% 65% 36% 6%

P (No serem detetados erros | sofreu erros) 0,00% 0,00% 0,00%

Pgina

28

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

0,00% 0,01% 0,98% 2% 5% 11,82%

Paridade 4bits
Probabilidade de Erro Probabilidade de Erro 0.0001% 0.001% 0.01% 0.1% 1.0% 10.0% 12.5% 25.0% 50.0% Erros Corrigidos 0 0 0 0 0 0 0 0 0 0,000001 0,00001 0,0001 0,001 0,01 0,1 0,125 0,25 0,5 Enviadas 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 Com Erros 44 487 5061 49897 490447 4096873 4872456 7627738 9687352 Sem Erros 9999956 9999513 9994939 9950103 9950103 5903127 5127544 2372262 312648 Erros Detetados 44 487 5059 49792 480800 3362318 3816530 4842032 5000862 Erros no Detetados 0 0 2 105 9647 734555 1055926 2785706 4686490

Prob. Tx s/erros - Pratico 0,9999956 0,9999513 0,9994939 0,9950103 0,9509553 0,5903127 0,5127544 0,2372262 0,0312648

Prob. Tx s/erros - Terico 0,9999950 0,9999500 0,9995001 0,9950100 0,9509900 0,5904900 0,5129089 0,2373047 0,0312500

Valor esperado de bits errados na trama 0,0000044 0,0000487 0,0005063 0,0500020 0,0500280 0,5001954 0,6250902 1,2503320 2,5003478

P (No serem detetados erros | sofreu erros) 0,0000000 0,0000000 0,0003952 0,2104335 1,9669811 17,9296502 21,6713296 36,5207352 48,3774100

Paridade 11bits
Probabilidade de Erro Probabilidade de Erro Enviadas Com Erros Sem Erros Erros Detetados

Pgina

29

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

0.0001% 0.001% 0.01% 0.1% 1.0% 10.0% 12.5% 25.0% 50.0% Erros no Detetados 0 0 7 650 59444 2520642 3140997 4681512 4999484

0,000001 0,00001 0,0001 0,001 0,01 0,1 0,125 0,25 0,5 Erros Corrigidos 0 0 0 0 0 0 0 0 0

10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000

120 1209 12114 119733 1135936 7176259 7986094 9683044 9997530

9999880 9998791 9987886 9880267 8864064 2823741 2013906 316956 2470

120 1209 12114 119083 1076492 655617 4845097 5001532 4998046 Prob. Tx s/erros - Terico 0,9999880 0,9998800 0,9988007 0,9880658 0,8863849 0,2824295 0,2014172 0,0316764 0,0002441

Prob. Tx s/erros - Pratico 0,999988 0,9998791 0,9987886 0,9880267 0,8864064 0,2823741 0,2013906 0,0316956 0,000247

Valor esperado de bits errados na trama 0,0000120 0,1209000 0,0012121 0,0120389 0,1199424 1,1998635 1,4998803 2,9999976 5,9997454

P (No serem detetados erros | sofreu erros) 0,0000000 0,0000000 0,0577844 0,5428746 5,2330413 35,1247356 39,3308293 48,3475238 50,0071918

P (Correo correta | sofreu erros) 0 0 0 0 0 0 0 0 0

CRC4

Pgina

30

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

Probabilidade de erro 0.0001% 0.001% 0.01% 0.1% 1.0% 10.0% 12.5% 25.0% 50.0% Erros No Detetados 0 0 0 8 929 60358 85989 252129 585401

Probabilidade de Erro 0,000001 0,00001 0,0001 0,001 0,01 0,1 0,125 0,25 0,5 Erros Corrigidos 0 0 0 0 0 0 0 0 0

Enviadas 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000

Com Erros 80 778 7903 79419 772206 5695667 6564542 8999613 9961251

Sem Erros 9999920 9999222 9992097 9920581 9227794 4304333 3435458 1000387 38749

Erros Detetados 80 778 7903 79411 771277 5635309 6478553 8747487 9375850

Prob. Tx s/erros - Pratico 0,9999920 0,9999222 0,9992097 0,9920581 0,9227794 0,4304333 0,3435458 0,1000387 0,0038749

Prob. Tx s/erros - Terico 0,9999920 0,9999200 0,9992003 0,9920279 0,9227447 0,4304672 0,3436089 0,1001129 0,0039063

Valor esperado de bits errados na trama 0,0000080 0,0000778 0,0007905 0,0079718 0,0799994 0,8003216 0,9998544 1,9995732 3,9999464

P (No serem detetados erros | sofreu erros) 0,0000000000% 0,0000000000% 0,0000000000% 0,0100731563% 0,1203044686% 1,0597178522% 1,3099009801% 2,8015204654% 5,8768194235%

CRC11
Probabilidade de erro 0.0001% 0.001% 0.01% 0.1% 1.0% 10.0% 12.5% 25.0% 50.0% Probabilidade de Erro 0,000001 0,00001 0,0001 0,001 0,01 0,1 0,125 0,25 0,5 Enviadas 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 10000000 Com Erros 161 1520 15132 148839 1398492 7941685 8649935 9866339 9999693 Sem Erros 9999839 9998480 9984868 9851161 8601508 2058315 1350065 133661 307 Erros Detetados 161 1520 15132 148758 1390604 7655631 8295366 9308560 9375790

Pgina

31

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

Erros No Detetados 0 0 0 81 7888 286054 354569 557779 623903

Erros Corrigidos 0 0 0 0 0 0 0 0 0

Prob. Tx s/erros - Pratico 0,9999839 0,9998480 0,9984868 0,9851161 0,8601508 0,2058315 0,1350065 0,0133661 0,0000307

Prob. Tx s/erros - Terico 0,9999850 0,9998500 0,9985010 0,9851045 0,8600584 0,2058911 0,1349338 0,0133635 0,0000305

Valor esperado de bits errados na trama 0,0000161 0,000152 0,0015144 0,0149882 0,1499627 1,5000914 1,8750661 3,7494986 7,4998183

P (No serem detetados erros | sofreu erros) 0,0000000% 0,0000000% 0,0000000% 0,5442122% 0,5640361% 3,6019308% 4,0990944% 5,6533533% 6,2392215%

package aplicacao; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; import import import import receptor.Receptor; canalRuidoso.CanalRuidoso; emissor.Emissor; ferramentasAuxiliares.FerramentasEMetodosAuxiliares;

public class Menu { private static final double NUM_TESTES = 10000000; private double numTestesEfectuados; private private private private int int int int modoFuncionamento = 0; tecnica = 0; numeroBitsDados = 0; modoGeracaoDados = 0;

private Emissor emissor = new Emissor(); private CanalRuidoso canalRuidoso = new CanalRuidoso(); private Receptor receptor = new Receptor();

public static void main(String[] args) { new Menu().menuInicial(); } private void menuInicial() { escolhaDoModoFuncionamento(); switch (modoFuncionamento) { case 1: demonstracao(); break;

Pgina

32

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

case 2: simulacao(); break; } } private void demonstracao() { escolhaDaTecnica(); escolhaNumeroBitsDados(); escolhaModoGeracaoDados(); demonstrarEnvioDeTrama(); reiniciar(); } private void simulacao() { escolhaDaTecnica(); escolhaNumeroBitsDados(); modoGeracaoDados = 2; escolhaDaProbabilidadeDeErroDeBit(); simularEnvioDeNTramas(); reiniciar(); } private void escolhaDoModoFuncionamento() { System.out.println("Trabalho pratico 1: Deteccao e correcao de erros\n\nEscolha do modo de funcionamento:\n1) Modo de Demonstracao\n2) Modo de Simulacao"); int modoFuncionamentoAux = FerramentasEMetodosAuxiliares.scanner.nextInt(); while (modoFuncionamentoAux < 1 || modoFuncionamentoAux > 2) { System.out.println("Opcao inexistente! \nEscolha uma das seguintes opcoes:\n1) Modo de Demonstracao\n2) Modo de Simulacao"); modoFuncionamentoAux = FerramentasEMetodosAuxiliares.scanner.nextInt(); } this.modoFuncionamento = modoFuncionamentoAux; } private void escolhaDaTecnica() { System.out.println("\nEscolha da tecnica de deteccao e correccao de erros:\n1) Bit Paridade\n2) CRC 23\n3) Codigo de Hamming"); int tecnicaAux = FerramentasEMetodosAuxiliares.scanner.nextInt(); while (tecnicaAux < 1 || tecnicaAux > 3) { System.out.println("Opcao inexistente! \nEscolha uma das seguintes opcoes:\n1) Bit Paridade\n2) CRC 23\n3) Codigo de Hamming"); tecnicaAux = FerramentasEMetodosAuxiliares.scanner.nextInt(); } this.tecnica = tecnicaAux; } private void escolhaNumeroBitsDados() { System.out.println("\nUtilizar tramas com:\n1) 4 bits de dados\n2) 11 bits de dados"); int numeroBitsDadosAux = FerramentasEMetodosAuxiliares.scanner.nextInt(); while (numeroBitsDadosAux < 1 || numeroBitsDadosAux > 2) { System.out.println("Opcao inexistente! \nEscolha uma das seguintes opcoes:\n1) 4 bits de dados\n2) 11 bits de dados"); numeroBitsDadosAux = FerramentasEMetodosAuxiliares.scanner.nextInt(); } if (numeroBitsDadosAux == 1) { this.numeroBitsDados = 4; }else { this.numeroBitsDados = 11; } } private void escolhaModoGeracaoDados() { System.out.println("\nEscolha do modo de geracao de dados:\n1) Manual\n2) Automatico"); int modoGeracaoDadosAux = FerramentasEMetodosAuxiliares.scanner.nextInt(); while (modoGeracaoDadosAux < 1 || modoGeracaoDadosAux > 2) { System.out.println("Opcao inexistente! \nEscolha uma das seguintes opcoes:\n1) Manual\n2) Automatico"); modoGeracaoDadosAux = FerramentasEMetodosAuxiliares.scanner.nextInt(); } this.modoGeracaoDados = modoGeracaoDadosAux; } private void escolhaDaProbabilidadeDeErroDeBit() { double pErroBit = FerramentasEMetodosAuxiliares.definirPeb(); canalRuidoso.setProbabilidadeDeErroDeBit(pErroBit); Pgina

33

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

} private void simularEnvioDeNTramas() { for (int i = 0; i < NUM_TESTES; i++) { simularEnvioDeTrama(); numTestesEfectuados++; receptor.reiniciarReceptor(); System.out.println(numTestesEfectuados/NUM_TESTES * 100); } detalhesSimulacao(); receptor.resetEstatisticas(); numTestesEfectuados=0; } private void demonstrarEnvioDeTrama() { emissor.gerarDadosETrama(this.tecnica, this.modoGeracaoDados, this.numeroBitsDados); canalRuidoso.gerarPadraoErrosEPassarTramaPeloCanalModoDemonstracao(this.modoGeracaoDados, this.tecnica, this.numeroBitsDados, emissor.getTramaAEnviar()); receptor.recebeTramaEDetectaECorrigeErros(canalRuidoso.getNovaTramaGerada(), this.tecnica, canalRuidoso.getPadraoErros()); detalhesDemonstracao(); receptor.reiniciarReceptor(); } private void detalhesDemonstracao() { System.out.println("\nConjunto dados res.imprimeBits(emissor.getDados())); System.out.println("Trama a emitir: res.imprimeBits(emissor.getTramaAEnviar())); System.out.println("Padrao de erros: res.imprimeBits(canalRuidoso.getPadraoErros())); System.out.println("Trama recebida: res.imprimeBits(receptor.getTramaRecebida())); System.out.println("Foram detectados System.out.println("Tcnica usada: " System.out.println("Trama corrigida: }

a emitir: " + FerramentasEMetodosAuxilia" + FerramentasEMetodosAuxilia" + FerramentasEMetodosAuxilia" + FerramentasEMetodosAuxiliaerros: " + receptor.houveErro()); + getTecnicaUsada()); " + receptor.getCorreccao() + "\n");

private void simularEnvioDeTrama() { emissor.gerarDadosETrama(this.tecnica, this.modoGeracaoDados, this.numeroBitsDados); canalRuidoso.gerarPadraoErrosEPassarTramaPeloCanalModoSimulacao(this.tecnica, this.numeroBitsDados, emissor.getTramaAEnviar()); receptor.recebeTramaEDetectaECorrigeErros(canalRuidoso.getNovaTramaGerada(), this.tecnica, canalRuidoso.getPadraoErros()); } private void detalhesSimulacao() { try { String numBits = "" + numeroBitsDados; String tecnica = getTecnicaUsada(); String probErro = "" + canalRuidoso.getProbabilidadeDeErroDeBit(); FileWriter outputTxt = new FileWriter("Simulacao para a tecnica " + tecnica + " com " + numBits + " bits e probabilidade de erro igual a " + probErro + ".txt"); PrintWriter out = new PrintWriter(outputTxt); out.println("SIMULACAO PARA A TECNICA " + tecnica + " COM " + numBits + " BITS E PROBABILIDADE DE ERRO IGUAL A " + probErro + ":"); out.println(); out.println("\nNumero total de tramas recebidas: " + receptor.getNumero_Total_Tramas()); out.println("Tramas recebidas sem erros: " + receptor.getTramas_Sem_Erros()); out.println("Tramas recebidas com erros: " + receptor.getTramas_Com_Erros()); out.println("Tramas recebidas com erros nao detectados: " + receptor.getTramas_Com_Erros_Nao_Detectados()); out.println("Tramas recebidas com erros detectados: " + receptor.getTramas_Com_Erros_Detectados()); out.println("Tramas recebidas e corrigidas: " + receptor.getTramas_Com_Erros_Detectados_E_Corrigidos()); out.println(); out.println("Probabilidade transmisso sem erros: " + (double)receptor.getTramas_Sem_Erros()/receptor.getNumero_Total_Tramas() *100 + "%"); out.println("Valor esperado de bits errados na trama: " + receptor.getValor_Esperado_NumeroBits_Errados_Na_Trama()/NUM_TESTES);

Pgina

34

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

out.println("Probabilidade de no serem detectados erros na trama dado que a trama sofreu erros: " + (double)receptor.getTramas_Com_Erros_Nao_Detectados()/receptor.getTramas_Com_Erros() *100 + "%"); out.println("Probabilidade de correco correcta dado que a trama sofreu erros: " + (double)receptor.getTramas_Com_Erros_Detectados_E_Corrigidos()/receptor.getTramas_Com_Erros() *100 + "%\n"); out.close(); } catch (IOException e) { System.err.println("Erro na escrita do ficheiro."); } } private void reiniciar() { System.out.println("Pretende continuar?(y/n)"); char end = FerramentasEMetodosAuxiliares.scanner.next().charAt(0); while (end != 'n' && end != 'N' && end != 'y' && end != 'Y') { System.out.println("Opcao invalida! \nEscolha uma das seguintes opcoes:\ny) Sim\nn) Nao"); end = FerramentasEMetodosAuxiliares.scanner.next().charAt(0); } if (end == 'y' || end == 'Y') { menuInicial(); }else { System.out.println("\nAplicao terminou!"); } } private String getTecnicaUsada() { switch (this.tecnica) { case 1: return "Bit de paridade"; case 2: return "CRC 23"; case 3: return "Codigo de Hamming"; } return null; } } package canalRuidoso; import ferramentasAuxiliares.FerramentasEMetodosAuxiliares; public class CanalRuidoso { private int[] padraoErros = new int[0]; private double probabilidadeDeErroDeBit = 0; private int[] novaTramaGerada = new int[0]; public void gerarPadraoErrosEPassarTramaPeloCanalModoDemonstracao(int modoGeracaoDados, int tecnica,int numeroBitsDados, int[] tramaAEnviar) { switch (modoGeracaoDados) { case 1: gerarPadraoErrosManualmente(tecnica, numeroBitsDados); break; case 2: escolherProbabilidadeErroBit(); gerarPadraoErrosAutomaticamente(tecnica, numeroBitsDados); break; } passagemPeloCanal(tramaAEnviar, padraoErros); } public void gerarPadraoErrosEPassarTramaPeloCanalModoSimulacao(int tecnica,int numeroBitsDados, int[] tramaAEnviar) { gerarPadraoErrosAutomaticamente(tecnica, numeroBitsDados); passagemPeloCanal(tramaAEnviar, padraoErros); } private void gerarPadraoErrosManualmente(int tecnica, int numeroBitsDados) { switch (tecnica) { case 1: gerarPadraoManualmente(numeroBitsDados, 1); break; case 2:

Pgina

35

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

gerarPadraoManualmente(numeroBitsDados, 4); break; case 3: gerarPadraoErrosHammingManualmente(numeroBitsDados); break; } } private void gerarPadraoErrosHammingManualmente(int numeroBitsDados) { switch (numeroBitsDados) { case 4: gerarPadraoManualmente(numeroBitsDados, 3); break; case 11: gerarPadraoManualmente(numeroBitsDados, 4); break; } } private void gerarPadraoManualmente(int numeroBitsDados, int bitsRedundancia) { int tamanhoPadraoErros = numeroBitsDados + bitsRedundancia; gerarManualmente(tamanhoPadraoErros); } private void gerarManualmente(int tamanhoTrama) { System.out.println("\nPadrao de erros com " + tamanhoTrama + "bits:"); String padraoErrosBPManualStringAux = FerramentasEMetodosAuxiliares.introduzirEAnalisarDados(tamanhoTrama); this.padraoErros = new int[tamanhoTrama]; for (int i = 0; i < padraoErros.length; i++) { padraoErros[i] = Integer.parseInt("" + padraoErrosBPManualStringAux.charAt(i)); } } private void escolherProbabilidadeErroBit() { System.out.println("\nIndique qual a probabilidade de erro de bit(formato: 0,x) : "); probabilidadeDeErroDeBit = FerramentasEMetodosAuxiliares.scanner.nextDouble(); while (probabilidadeDeErroDeBit < 0 || probabilidadeDeErroDeBit > 1) { System.out.println("Valor invalido! Tente novamente(formato: 0,x - 0 a 1):"); probabilidadeDeErroDeBit = FerramentasEMetodosAuxiliares.scanner.nextDouble(); } } private void gerarPadraoErrosAutomaticamente(int tecnica, int numeroBitsDados) { switch (tecnica) { case 1: gerarPadraoAutomaticamente(numeroBitsDados, 1); break; case 2: gerarPadraoAutomaticamente(numeroBitsDados, 4); break; case 3: gerarPadraoErrosHammingAutomaticamente(numeroBitsDados); break; } } private void gerarPadraoErrosHammingAutomaticamente(int numeroBitsDados) { switch (numeroBitsDados) { case 4: gerarPadraoAutomaticamente(numeroBitsDados, 3); break; case 11: gerarPadraoAutomaticamente(numeroBitsDados, 4); break; } } private void gerarPadraoAutomaticamente(int numeroBitsDados, int bitsRedundancia) { int tamanhoPadraoErros = numeroBitsDados + bitsRedundancia; gerarAutomaticamente(tamanhoPadraoErros); } private void gerarAutomaticamente(int tamanhoPadraoErros) { this.padraoErros = new int[tamanhoPadraoErros]; for (int i = 0; i < padraoErros.length; i++) {

Pgina

36

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

if(FerramentasEMetodosAuxiliares.geradorAleatorios.nextDouble() <= probabilidadeDeErroDeBit) padraoErros[i] = 1; else padraoErros[i] = 0; } } private void passagemPeloCanal(int[] tramaEmitida, int[] padraoDeErros){ novaTramaGerada = new int[tramaEmitida.length]; for (int i = 0; i < novaTramaGerada.length; i++) { novaTramaGerada[i] = tramaEmitida[i] ^ padraoDeErros[i]; } } public int[] getPadraoErros() { return padraoErros; } public double getProbabilidadeDeErroDeBit() { return probabilidadeDeErroDeBit; } public int[] getNovaTramaGerada() { return novaTramaGerada; } public void setProbabilidadeDeErroDeBit(double probabilidadeDeErroDeBit) { this.probabilidadeDeErroDeBit = probabilidadeDeErroDeBit; }

} package emissor; import ferramentasAuxiliares.FerramentasEMetodosAuxiliares; public class Emissor { private int[] dados = new int[0]; private int[] tramaAEnviar = new int[0]; public void gerarDadosETrama(int tecnica, int modoGeracaoDados, int numeroBitsDados){ switch (modoGeracaoDados) { case 1: gerarDadosManualmente(numeroBitsDados); break; case 2: gerarDadosAutomaticamente(numeroBitsDados); break; } gerarTramaAEnviar(tecnica, numeroBitsDados); } private void gerarDadosManualmente(int numeroBitsDados) { System.out.println("\nDados a enviar com " + numeroBitsDados + "bits:"); String dadosIntroduzidos = FerramentasEMetodosAuxiliares.introduzirEAnalisarDados(numeroBitsDados); this.dados = new int[numeroBitsDados]; for (int i = 0; i < dados.length; i++) { dados[i] = Integer.parseInt("" + dadosIntroduzidos.charAt(i)); } } private void gerarDadosAutomaticamente(int numeroBitsDados) { dados = new int[numeroBitsDados]; for (int i = 0; i < dados.length; i++) { if(FerramentasEMetodosAuxiliares.geradorAleatorios.nextDouble() >= 0.5) dados[i] = 1; else dados[i] = 0; } } private void gerarTramaAEnviar(int tecnica, int numeroBitsDados) { switch (tecnica) {

Pgina

37

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

case 1: gerarTramaBitParidade(numeroBitsDados); break; case 2: gerarTramaCRC23(numeroBitsDados); break; case 3: gerarTramaHamming(numeroBitsDados); break; } } private void gerarTramaBitParidade(int numeroBitsDados) { tramaAEnviar = new int[numeroBitsDados+1]; int valorBitParidadeAux = 0; for (int i = 0; i < dados.length; i++) { if (dados[i] == 1) valorBitParidadeAux++; tramaAEnviar[i] = dados[i]; } if (valorBitParidadeAux % 2 == 1) { tramaAEnviar[numeroBitsDados] = 1; }else { tramaAEnviar[numeroBitsDados] = 0; } } private void gerarTramaCRC23(int numeroBitsDados) { tramaAEnviar = new int[numeroBitsDados + 4]; for (int i = 0; i < dados.length; i++) { tramaAEnviar[i] = dados[i]; } for (int i = dados.length; i < tramaAEnviar.length; i++) { tramaAEnviar[i] = 0; } int i0 = 0, i1 = 0, i2 = 0, i3 = 0, c0 = 0, c1 = 0, c2 = 0, c3 = 0; for (int i = 0; i < tramaAEnviar.length; i++) { i0 = tramaAEnviar[i] ^ c3; i1 = c0 ^ c3; i2 = c1 ^ c3; i3 = c2; c0 = i0; c1 = i1; c2 = i2; c3 = i3; } System.arraycopy(dados, 0, tramaAEnviar, 0, numeroBitsDados); tramaAEnviar[numeroBitsDados] = c3; tramaAEnviar[numeroBitsDados + 1] = c2; tramaAEnviar[numeroBitsDados + 2] = c1; tramaAEnviar[numeroBitsDados + 3] = c0; } private void gerarTramaHamming(int numeroBitsDados) { switch (numeroBitsDados) { case 4: gerarTramaHamming4bitsUteis(numeroBitsDados); break; case 11: gerarTramaHamming11bitsUteis(numeroBitsDados); break; } } private void gerarTramaHamming4bitsUteis(int numeroBitsDados) { tramaAEnviar = new int[numeroBitsDados+3]; int indice4DadosAux = 0; for (int i = 0; i < tramaAEnviar.length; i++) { if (i == 2 || i == 4 || i ==5 || i ==6) { tramaAEnviar[i] = dados[indice4DadosAux]; indice4DadosAux++; } } tramaAEnviar[0]= tramaAEnviar[2] ^ tramaAEnviar[4] ^ tramaAEnviar[6]; tramaAEnviar[1]= tramaAEnviar[2] ^ tramaAEnviar[5] ^ tramaAEnviar[6]; tramaAEnviar[3]= tramaAEnviar[4] ^ tramaAEnviar[5] ^ tramaAEnviar[6]; }

Pgina

38

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

private void gerarTramaHamming11bitsUteis(int numeroBitsDados) { tramaAEnviar = new int[numeroBitsDados+4]; int indice11DadosAux = 0; for (int i = 0; i < tramaAEnviar.length; i++) { if (i == 2 || i == 4 || i ==5 || i ==6 || i == 8 || i == 9 || i == 10 || i == 11 || i == 12 || i == 13 || i == 14) { tramaAEnviar[i] = dados[indice11DadosAux]; indice11DadosAux++; } } tramaAEnviar[0]= tramaAEnviar[2] ^ tramaAEnviar[4] ^ tramaAEnviar[6] ^ tramaAEnviar[8] ^ tramaAEnviar[10] ^ tramaAEnviar[12] ^ tramaAEnviar[14]; tramaAEnviar[1]= tramaAEnviar[2] ^ tramaAEnviar[5] ^ tramaAEnviar[6] ^ tramaAEnviar[9] ^ tramaAEnviar[10] ^ tramaAEnviar[13] ^ tramaAEnviar[14]; tramaAEnviar[3]= tramaAEnviar[4] ^ tramaAEnviar[5] ^ tramaAEnviar[6] ^ tramaAEnviar[11] ^ tramaAEnviar[12] ^ tramaAEnviar[13] ^ tramaAEnviar[14]; tramaAEnviar[7]= tramaAEnviar[8] ^ tramaAEnviar[9] ^ tramaAEnviar[10] ^ tramaAEnviar[11] ^ tramaAEnviar[12] ^ tramaAEnviar[13] ^ tramaAEnviar[14]; } public int[] getDados() { return dados; } public int[] getTramaAEnviar() { return tramaAEnviar; } } package ferramentasAuxiliares; import java.util.Random; import java.util.Scanner; public class FerramentasEMetodosAuxiliares { public static Scanner scanner = new Scanner(System.in); public static Random geradorAleatorios = new Random(); public static String imprimeBits(int[] dados){ String s = ""; for(int i = 0; i != dados.length ; i++){ s += " " + dados[i]; } return s ; } public static String introduzirEAnalisarDados(int numeroBitsDados) { String dadosIntroduzidos = FerramentasEMetodosAuxiliares.scanner.next(); boolean dadosAceitaveis = false; boolean dadosBemIntroduzidos = false; while (!dadosAceitaveis && !dadosBemIntroduzidos) { while (!dadosBemIntroduzidos) { dadosBemIntroduzidos = dadosBemIntroduzidos(dadosIntroduzidos, numeroBitsDados); if (!dadosBemIntroduzidos) dadosIntroduzidos = FerramentasEMetodosAuxiliares.scanner.next(); } if (dadosIntroduzidos.length() != numeroBitsDados) { System.out.println("Conjunto de dados nao permitido(Tamanho incorrecto)! \nEscolha novamente " + "(" + numeroBitsDados + "bits):"); dadosIntroduzidos = FerramentasEMetodosAuxiliares.scanner.next(); dadosAceitaveis = false; dadosBemIntroduzidos = false; } else if (dadosIntroduzidos.length() == numeroBitsDados && dadosBemIntroduzidos) { dadosAceitaveis = true; } } return dadosIntroduzidos; } public static boolean dadosBemIntroduzidos(String dadosIntroduzidos, int numeroBitsDados) { for (int i = 0; i < dadosIntroduzidos.length(); i++) { if (dadosIntroduzidos.charAt(i) != '0' && dadosIntroduzidos.charAt(i) != '1'){

Pgina

39

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

System.out.println("Conjunto de dados nao permitido(bits incorrectos)! \nEscolha novamente " + "(" + numeroBitsDados + "bits):"); return false; } } return true; } public static final double[] probabilidades = {0.5, 0.25, 0.125, 0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001}; public static double definirPeb() { System.out.println("\nIndique qual a probabilidade de erro de bit : "); double prob = 0; for (int i = 0; i < probabilidades.length; i++){ System.out.println(i+1 + ") " + probabilidades[i] + " "); } int probabilidadeSelecionada = scanner.nextInt(); while (probabilidadeSelecionada < 1 || probabilidadeSelecionada > 9) { System.out.println("Opcao inexistente! \nEscolha uma das seguintes opcoes:\n"); for (int i = 0; i < probabilidades.length; i++){ System.out.println(i+1 + ") " + probabilidades[i] + " "); } probabilidadeSelecionada = scanner.nextInt(); } prob = probabilidades[probabilidadeSelecionada-1]; return prob; } } package receptor; public class Receptor { private int[] tramaRecebida = new int[0]; private boolean temErro = false; private int[] tramaCorrigida = new int[0]; private boolean temCorrecao = false; private private private private private private private int int int int int int int tramas_Sem_Erros = 0; numero_Total_Tramas = 0; valor_Esperado_NumeroBits_Errados_Na_Trama = 0; tramas_Com_Erros = 0; tramas_Com_Erros_Nao_Detectados = 0; tramas_Com_Erros_Detectados = 0; tramas_Com_Erros_Detectados_E_Corrigidos = 0;

public void recebeTramaEDetectaECorrigeErros(int[] novaTramaGerada, int tecnica, int[] padraoErros) { recebeTrama(novaTramaGerada); int numeroErros = calcularNumeroErros(padraoErros); procuraECorrigeErros(tecnica, numeroErros); } private void recebeTrama(int[] tramaRecebida) { this.tramaRecebida = new int[tramaRecebida.length]; for (int i = 0; i < tramaRecebida.length; i++) { this.tramaRecebida[i] = tramaRecebida[i]; } numero_Total_Tramas++; } private int calcularNumeroErros(int[] padraoErros) { int erros = 0; for (int i = 0; i < padraoErros.length; i++) { if (padraoErros[i] == 1) { erros++; valor_Esperado_NumeroBits_Errados_Na_Trama++; } } if (erros != 0) { tramas_Com_Erros++; }else { tramas_Sem_Erros++; } return erros; }

Pgina

40

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

private void procuraECorrigeErros(int tecnica, int numeroErros){ int tamanhoTramaRecebida = tramaRecebida.length; switch (tecnica) { case 1: procuraErroBitDeParidade(tamanhoTramaRecebida, numeroErros); break; case 2: procuraErroCRC23(tamanhoTramaRecebida, numeroErros); break; case 3: procuraErroHamming(tamanhoTramaRecebida, numeroErros); break; } } private void procuraErroBitDeParidade(int tamanhoTramaRecebida, int numeroErros) { int paridade = 0; int bitsUteis = tamanhoTramaRecebida - 1; int bitDeParidade = tramaRecebida[tamanhoTramaRecebida-1]; for (int i = 0; i < bitsUteis; i++) { if (tramaRecebida[i] == 1) paridade++; } if (paridade % 2 == 0 && bitDeParidade == 0 || paridade % 2 == 1 && bitDeParidade == 1) { temErro = false; if (numeroErros > 0) { tramas_Com_Erros_Nao_Detectados++; } }else { temErro = true; tramas_Com_Erros_Detectados++; } } private void procuraErroCRC23(int tamanhoTramaRecebida, int numeroErros) { int i0 = 0, i1 = 0, i2 = 0, i3 = 0, c0 = 0, c1 = 0, c2 = 0, c3 = 0; for (int i = 0; i < tamanhoTramaRecebida; i++) { i0 = tramaRecebida[i] ^ c3; i1 = c0 ^ c3; i2 = c1 ^ c3; i3 = c2; c0 = i0; c1 = i1; c2 = i2; c3 = i3; } if (c0 == 0 && c1 == 0 && c2 == 0 && c3 == 0) { temErro=false; if (numeroErros > 0) { tramas_Com_Erros_Nao_Detectados++; } }else { temErro=true; tramas_Com_Erros_Detectados++; } } private void procuraErroHamming(int tamanhoTramaRecebida, int numeroErros) { switch (tamanhoTramaRecebida) { case 7: procuraErroHamming7(tamanhoTramaRecebida, numeroErros); break; case 15: procuraErroHamming15(tamanhoTramaRecebida, numeroErros); break; } } private void procuraErroHamming7(int tamanhoTramaRecebida, int numeroErros) { int c0 = tramaRecebida[2] ^ tramaRecebida[4] ^ tramaRecebida[6] ^ tramaRecebida[0]; int c1 = tramaRecebida[2] ^ tramaRecebida[5] ^ tramaRecebida[6] ^ tramaRecebida[1]; int c3 = tramaRecebida[4] ^ tramaRecebida[5] ^ tramaRecebida[6] ^ tramaRecebida[3]; int[] checkBits = {c0, c1, c3}; for (int i = 0; i < checkBits.length; i++) { if (checkBits[i] == 1) { Pgina

41

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

tramas_Com_Erros_Detectados++; temErro = true; break; } } if (numeroErros > 0 && !temErro) { tramas_Com_Erros_Nao_Detectados++; } if (temErro) corrigeErroHamming7(checkBits, numeroErros); } private void corrigeErroHamming7(int[] checkBits, int numeroErros) { int bitErrado = 0; if (checkBits[0] == 1) { bitErrado+=1; } if (checkBits[1] == 1) { bitErrado+=2; } if (checkBits[2] == 1) { bitErrado+=4; } corrigeErroHamming(bitErrado, numeroErros); } private void procuraErroHamming15(int tamanhoTramaRecebida, int numeroErros) { int c0 = tramaRecebida[2] ^ tramaRecebida[4] ^ tramaRecebida[6] ^ tramaRecebida[8] ^ tramaRecebida[10] ^ tramaRecebida[12] ^ tramaRecebida[14] ^ tramaRecebida[0]; int c1 = tramaRecebida[2] ^ tramaRecebida[5] ^ tramaRecebida[6] ^ tramaRecebida[9] ^ tramaRecebida[10] ^ tramaRecebida[13] ^ tramaRecebida[14] ^ tramaRecebida[1]; int c3 = tramaRecebida[4] ^ tramaRecebida[5] ^ tramaRecebida[6] ^ tramaRecebida[11] ^ tramaRecebida[12] ^ tramaRecebida[13] ^ tramaRecebida[14] ^ tramaRecebida[3]; int c7 = tramaRecebida[8] ^ tramaRecebida[9] ^ tramaRecebida[10] ^ tramaRecebida[11] ^ tramaRecebida[12] ^ tramaRecebida[13] ^ tramaRecebida[14] ^ tramaRecebida[7]; int[] checkBits = {c0, c1, c3, c7}; for (int i = 0; i < checkBits.length; i++) { if (checkBits[i] == 1) { tramas_Com_Erros_Detectados++; temErro = true; break; } } if (numeroErros > 0 && !temErro) { tramas_Com_Erros_Nao_Detectados++; } if (temErro) corrigeErroHamming15(checkBits, numeroErros); } private void corrigeErroHamming15(int[] checkBits, int numeroErros) { int bitErrado = 0; if (checkBits[0] == 1) { bitErrado+=1; } if (checkBits[1] == 1) { bitErrado+=2; } if (checkBits[2] == 1) { bitErrado+=4; } if (checkBits[3] == 1) { bitErrado+=8; } corrigeErroHamming(bitErrado, numeroErros); } private void corrigeErroHamming(int bitErrado, int numeroErros) { tramaCorrigida = new int[tramaRecebida.length]; for (int i = 0; i < tramaCorrigida.length; i++) { tramaCorrigida[i] = tramaRecebida[i]; if (i == bitErrado-1){ tramaCorrigida[i] = tramaRecebida[i] ^ 1; temCorrecao = true; } } Pgina

42

Redes Digitais I

Grupo rd1_tA-02

Deteo e Correo de Erros

if (numeroErros == 1) { tramas_Com_Erros_Detectados_E_Corrigidos++; } } public int[] getTramaRecebida() { return tramaRecebida; } public boolean temErro() { return temErro; } public String houveErro() { String aux = ""; if (temErro) aux = "Sim."; else aux = "Nao."; return aux; } public String getCorreccao() { String aux = ""; if (!temCorrecao ) { aux = "No se aplica"; }else { for (int i = 0; i < tramaCorrigida.length; i++) { aux+=tramaCorrigida[i]; } } return aux; } public int getTramas_Sem_Erros() { return tramas_Sem_Erros; } public int getNumero_Total_Tramas() { return numero_Total_Tramas; } public int getValor_Esperado_NumeroBits_Errados_Na_Trama() { return valor_Esperado_NumeroBits_Errados_Na_Trama; } public int getTramas_Com_Erros() { return tramas_Com_Erros; } public int getTramas_Com_Erros_Nao_Detectados() { return tramas_Com_Erros_Nao_Detectados; } public int getTramas_Com_Erros_Detectados_E_Corrigidos() { return tramas_Com_Erros_Detectados_E_Corrigidos; } public int getTramas_Com_Erros_Detectados() { return tramas_Com_Erros_Detectados; } public void reiniciarReceptor(){ temErro=false; temCorrecao=false; tramaCorrigida = new int[0]; tramaRecebida = new int[0]; } public void resetEstatisticas() { tramas_Com_Erros = 0; tramas_Com_Erros_Detectados = 0; tramas_Com_Erros_Detectados_E_Corrigidos = 0; numero_Total_Tramas = 0; tramas_Sem_Erros = 0; valor_Esperado_NumeroBits_Errados_Na_Trama = 0; tramas_Com_Erros_Nao_Detectados = 0; } } Pgina

43