Transmisja danych

laboratorium

Kierunek studiów:	Informatyka	Rok studiów:	III
Numer grupy:	W1 C2 L4 P4
Rok akademicki:	2012/2013	Semestr:	V

Temat:
Kodowanie nadmiarowe - kod Hamminga

Lp.	Nr indeksu	Imię i nazwisko	Data oddania I	Data oddania II	OCENA
1.	78202	Arkadiusz Kurasz	2012-10-24
2.

Termin zajęć:		Prowadzący:
dzień:	Środa	^dr Zygarlicka Małgorzata
godzina:	15:30-16:15

I. Cel ćwiczenia.

Celem ćwiczenia jest praktyczne poznanie kodu Haminnga w ujęciu ogólnym i macierzowym. Na podstawie przykładów pokazano metodę, która pozwala na przechwytywanie i skuteczne naprawianie błędów powstałych podczas transmisji. Owa metoda pozwala użytkownikowi na pewną, skuteczną kontrolę poprawności przesyłanych danych. Kolejny cel ćwiczenia polega na nabyciu umiejętności sprawdzenia poprawności danych metodą rachunkową jak i za pomocą programu Matlab - Simulink.

II. Wstęp teoretyczny.

1. Kod nadmiarowy

Metody kodowania nadmiarowego polegają na dodaniu do wiadomości dodatkowych symboli, dzięki którym można stwierdzić, czy i w którym miejscu wiadomości wystąpił błąd.
Kody nadmiarowe dzielimy na:

• liniowe - oblicza się je korzystając z operacji liniowych, głównie z operacji dodawania w arytmetyce nad ciałem Galois. Najczęściej stosowanym kodem liniowym jest kod Hamminga.

• nieliniowe - oblicza się je korzystając z operacji nieliniowych, wykorzystując wielomiany, np. CRC-16-CCIT, CRC-32-IEEE 802.3.

2. Kod Hamminga

1. Pojęcia podstawowe

Wagą Hamminga dowolnego ciągu bitów nazywamy liczbę jedynek w tym ciągu. Wagę Hamminga ciągu bitowego x oznaczamy przez W(x).

Odległość Hamminga dwóch ciągów bitowych x₁ i x₂ definiuje się jako liczbę indeksów, na których wartości indeksów różnią się. Odległość tę oznaczamy jako d(x₁, x₂). Formalnie można zapisać:

d(x₁, x₂)=W(x₁+x₂)

gdzie wynikiem operacji dodawania jest ciąg bitowy, którego wyrazami są sumy odpowiadających wyrazów ciągu x1 i x2 modulo 2.

Słowo informacyjne to ciąg bitów reprezentujący dane przeznaczone dla transmisji.

Słowo nadmiarowe to ciąg bitów służących do kontroli poprawności transmitowanych danych oraz do ich ewentualnej korekty.

Słowo kodowe to ciąg bitów złożony z bitów słowa informacyjnego i nadmiarowego. Jeśli słowo kodowe ma długość n, to można zapisać 2n słów kodowych. Część z nich należy do kodu, pozostałe uznawane są za niepoprawne. Do tego, aby stwierdzić, czy dane słowo kodowe należy do kodu służy algorytm odnajdywania błędu.

Nadawca wysłał wiadomość (x_K,x_R), gdzie x_K oznacza przesyłane dane, a x_R odpowiadający im kod nadmiarowy. Odbiorca odbierze wiadomość (x'_K,x'_R). Aby stwierdzić, czy otrzymane dane są poprawne odbiorca musi sam obliczyć kod nadmiarowy x⁽²⁾_R dla wiadomości x'_K, a następnie syndrom błędu, który z definicji jest równy x'_R+ x⁽²⁾_R. Jeżeli syndrom błędu jest różny od 0, oznacza to że w transmisji wystąpił błąd.

2. Ogólny kod Hamminga

Algorytm użycia parzystości dla ogólnego kodu Hamminga jest następujący:

• wszystkie pozycje bitów, które są potęgami dwójki, są użyte jako bity parzystości,

• wszystkie pozostałe pozycje służą do kodowania danych,

• każdy bit parzystości obliczany jest na podstawie parzystości pewnych bitów w kodowanym słowie. Pozycja bitu parzystości określa, które bity mają byd sprawdzane, a które pomijane. Numeracja bitów zaczyna się od 1, natomiast jako pierwszy sprawdzany jest bit na pozycji n+1. I tak:

• pozycja 1 (n=1): pomio 0 bitów (n-1), sprawdź 1 bit (n), pomio 1 bit (n), sprawdź 1 bit (n) itd.

• pozycja 2 (n=2): pomio 1 bit (n-1), sprawdź 2 bity (n), pomio 2 bity (n), sprawdź 2 bity (n) itd.

• pozycja 4 (n=4): pomio 3 bity (n-1), sprawdź 4 bity (n), pomio 4 bity (n), sprawdź 4 bity (n) itd.

• pozycja i (n=i): pomio i-1 bitów, sprawdź i bitów, pomio i bitów, sprawdź i bitów itd.

1. Kod Hamminga w ujęciu macierzowym

Kod Hamminga może byd również opisany przy pomocy zerojedynkowej macierzy oznaczonej przez H.

Założenia:

• kod korygujący pojedynczy błąd bitowy - aby możliwe było określenie bitu na którym wystąpił błąd i naprawienie go, macierz z której będziemy korzystad musi spełniad następujące wymogi:

• żadna z dwóch kolumn macierzy nie może byd identyczna,

• żadna z kolumn macierzy H nie może byd kolumną zerową, tzn. w każdej z kolumn macierzy nie mogą wystąpid same zera.

• kod korygujący podwójny błąd bitowy - dla kodu korygującego podwójny błąd bitowy, macierz H musi spełaniad te same założenia co przy kodzie korygującym pojedynczy błąd bitowy, jednak dodatkowo musi spełniad następujący warunek:

• żadna z kolumn macierzy H nie może byd sumą dwóch innych kolumn macierzy H.

III. Wykaz przyrządów.

Do ćwiczenia wykorzystany został program „Matlab ( Simulink )”.

IV. Schematy pomiarowe stosowane w ćwiczeniu.

W ćwiczeniu nie zostały wygenerowane, ani wykorzystane żadne schematy pomiarowe.

V. Obliczenia parametrów wyznaczonych w ćwiczeniach.

W obliczeniach wykorzystałem poniższe macierze:

1. Macierz H:

| 1 0 0 0 1 0 1 1 | 1 0 0 0 |

| 1 1 1 0 0 1 0 1 | 0 1 0 0 | = H

| 0 1 0 1 1 1 0 0 | 0 0 1 0 |

| 1 0 1 1 1 1 1 0 | 0 0 0 1 |

2. Kolejne macierze dla każdej z kodowanych liter:

`A' = [ 0 1 0 0 0 0 0 1 ]

`R' = [ 0 1 0 1 0 0 1 0 ]

`E' = [ 0 1 0 0 0 1 0 1 ]

`K' = [ 0 1 0 0 1 0 1 1 ]

`K' = [ 0 1 0 0 1 0 1 1 ]

`U' = [ 0 1 0 1 0 1 0 1 ]

`R' = [ 0 1 0 1 0 0 1 0 ]

`A' = [ 0 1 0 0 0 0 0 1 ]

`S' = [ 0 1 0 0 1 1 0 1 ]

`Z' = [ 0 1 0 1 1 0 1 0 ]

`V' = [ 0 1 0 1 0 1 1 0 ]

3. Poprawne zakodowanie litery `A':

A = [ 0 1 0 0 0 0 0 1 ]

| 0*1 + 1*0 + 0*0 + 0*0 + 0*1 + 0*0 + 0*1 + 1*1 | = | 1 |

A*H = | 0*1 + 1*1 + 0*1 + 0*0 + 0*0 + 0*1 + 0*0 + 1*1 | = | 2 |

| 0*0 + 1*1 + 0*0 + 0*1 + 0*1 + 0*1 + 0*0 + 1*0 | = | 1 |

| 0*1 + 1*0 + 0*1 + 0*1 + 0*1 + 0*1 + 0*1 + 1*0 | = | 0 |

| 1 | | 1 |

PR =| 2 | modulo 2 = | 0 |

| 1 | | 1 |

| 0 | | 0 |

A = [ 0 1 0 0 0 0 0 1 ][ 1 0 1 0 ]

| 0*1 + 1*0 + 0*0 + 0*0 + 0*1 + 0*0 + 0*1 + 1*1 + 1*1 + 0*0 + 1*0 + 0*0 | = | 2 |

Az*H =| 0*1 + 1*1 + 0*1 + 0*0 + 0*0 + 0*1 + 0*0 + 1*1 + 1*0 + 0*1 + 1*0 + 0*0 | = | 2 |

| 0*0 + 1*1 + 0*0 + 0*1 + 0*1 + 0*1 + 0*0 + 1*0 + 1*0 + 0*0 + 1*1 + 0*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 0*1 + 0*1 + 0*1 + 0*1 + 1*0 + 1*0 + 0*0 + 1*0 + 0*1 | = | 0 |

| 2 | | 0 |

PR =| 2 | modulo 2 = | 0 |

| 2 | | 0 |

| 0 | | 0 |

4. Poprawne zakodowanie litery `R':

R = [ 0 1 0 1 0 0 1 0 ]

| 0*1 + 1*0 + 0*0 + 1*0 + 0*1 + 0*0 + 1*1 + 0*1 | = | 1 |

R*H = | 0*1 + 1*1 + 0*1 + 1*0 + 0*0 + 0*1 + 1*0 + 0*1 | = | 1 |

| 0*0 + 1*1 + 0*0 + 1*1 + 0*1 + 0*1 + 1*0 + 0*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 1*1 + 0*1 + 0*1 + 1*1 + 0*0 | = | 2 |

| 1 | | 1 |

PR =| 1 | modulo 2 = | 1 |

| 2 | | 0 |

| 2 | | 0 |

R = [ 0 1 0 1 0 0 1 0 ] [ 1 1 0 0 ]

| 0*1 + 1*0 + 0*0 + 1*0 + 0*1 + 0*0 + 1*1 + 0*1 + 1*1 + 1*0 + 0*0 + 0*0 | = | 2 |

Rz*H =| 0*1 + 1*1 + 0*1 + 1*0 + 0*0 + 0*1 + 1*0 + 0*1 + 1*0 + 1*1 + 0*0 + 0*0 | = | 2 |

| 0*0 + 1*1 + 0*0 + 1*1 + 0*1 + 0*1 + 1*0 + 0*0 + 1*0 + 1*0 + 0*1 + 0*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 1*1 + 0*1 + 0*1 + 1*1 + 0*0 + 1*0 + 1*0 + 0*0 + 0*1 | = | 2 |

| 2 | | 0 |

PR =| 2 | modulo 2 = | 0 |

| 2 | | 0 |

| 2 | | 0 |

5. Poprawne zakodowanie litery `E':

E = [ 0 1 0 0 0 1 0 1 ]

| 0*1 + 1*0 + 0*0 + 0*0 + 0*1 + 1*0 + 0*1 + 1*1 | = | 1 |

E*H = | 0*1 + 1*1 + 0*1 + 0*0 + 0*0 + 1*1 + 0*0 + 1*1 | = | 3 |

| 0*0 + 1*1 + 0*0 + 0*1 + 0*1 + 1*1 + 0*0 + 1*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 0*1 + 0*1 + 1*1 + 0*1 + 1*0 | = | 1 |

| 1 | | 1 |

PR =| 3 | modulo 2 = | 1 |

| 2 | | 0 |

| 1 | | 1 |

E = [ 0 1 0 0 0 1 0 1 ] [ 1 1 0 1 ]

| 0*1 + 1*0 + 0*0 + 0*0 + 0*1 + 1*0 + 0*1 + 1*1 + 1*1 + 1*0 + 0*0 + 1*0 | = | 2 |

Ez*H =| 0*1 + 1*1 + 0*1 + 0*0 + 0*0 + 1*1 + 0*0 + 1*1 + 1*0 + 1*1 + 0*0 + 1*0 | = | 4 |

| 0*0 + 1*1 + 0*0 + 0*1 + 0*1 + 1*1 + 0*0 + 1*0 + 1*0 + 1*0 + 0*1 + 1*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 0*1 + 0*1 + 1*1 + 0*1 + 1*0 + 1*0 + 1*0 + 0*0 + 1*1 | = | 2 |

| 2 | | 0 |

PR =| 4 | modulo 2 = | 0 |

| 2 | | 0 |

| 2 | | 0 |

6. Poprawne zakodowanie litery `K':

K = [ 0 1 0 0 1 0 1 1 ]

| 0*1 + 1*0 + 0*0 + 0*0 + 1*1 + 0*0 + 1*1 + 1*1 | = | 3 |

K*H = | 0*1 + 1*1 + 0*1 + 0*0 + 1*0 + 0*1 + 1*0 + 1*1 | = | 2 |

| 0*0 + 1*1 + 0*0 + 0*1 + 1*1 + 0*1 + 1*0 + 1*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 0*1 + 1*1 + 0*1 + 1*1 + 1*0 | = | 2 |

| 3 | | 1 |

PR =| 2 | modulo 2 = | 0 |

| 2 | | 0 |

| 2 | | 0 |

K = [ 0 1 0 0 1 0 1 1 ] [ 1 0 0 0 ]

| 0*1 + 1*0 + 0*0 + 0*0 + 1*1 + 0*0 + 1*1 + 1*1 + 1*1 + 0*0 + 0*0 + 0*0 | = | 4 |

Kz*H =| 0*1 + 1*1 + 0*1 + 0*0 + 1*0 + 0*1 + 1*0 + 1*1 + 1*0 + 0*1 + 0*0 + 0*0 | = | 2 |

| 0*0 + 1*1 + 0*0 + 0*1 + 1*1 + 0*1 + 1*0 + 1*0 + 1*0 + 0*0 + 0*1 + 0*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 0*1 + 1*1 + 0*1 + 1*1 + 1*0 + 1*0 + 0*0 + 0*0 + 0*1 | = | 2 |

| 4 | | 0 |

PR =| 2 | modulo 2 = | 0 |

| 2 | | 0 |

| 2 | | 0 |

7. Poprawne zakodowanie litery `K':

K = [ 0 1 0 0 1 0 1 1 ]

| 0*1 + 1*0 + 0*0 + 0*0 + 1*1 + 0*0 + 1*1 + 1*1 | = | 3 |

K*H = | 0*1 + 1*1 + 0*1 + 0*0 + 1*0 + 0*1 + 1*0 + 1*1 | = | 2 |

| 0*0 + 1*1 + 0*0 + 0*1 + 1*1 + 0*1 + 1*0 + 1*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 0*1 + 1*1 + 0*1 + 1*1 + 1*0 | = | 2 |

| 3 | | 1 |

PR =| 2 | modulo 2 = | 0 |

| 2 | | 0 |

| 2 | | 0 |

K = [ 0 1 0 0 1 0 1 1 ] [ 1 0 0 0 ]

| 0*1 + 1*0 + 0*0 + 0*0 + 1*1 + 0*0 + 1*1 + 1*1 + 1*1 + 0*0 + 0*0 + 0*0 | = | 4 |

Kz*H =| 0*1 + 1*1 + 0*1 + 0*0 + 1*0 + 0*1 + 1*0 + 1*1 + 1*0 + 0*1 + 0*0 + 0*0 | = | 2 |

| 0*0 + 1*1 + 0*0 + 0*1 + 1*1 + 0*1 + 1*0 + 1*0 + 1*0 + 0*0 + 0*1 + 0*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 0*1 + 1*1 + 0*1 + 1*1 + 1*0 + 1*0 + 0*0 + 0*0 + 0*1 | = | 2 |

| 4 | | 0 |

PR =| 2 | modulo 2 = | 0 |

| 2 | | 0 |

| 2 | | 0 |

8. Poprawne zakodowanie litery `U':

U = [ 0 1 0 1 0 1 0 1 ]

| 0*1 + 1*0 + 0*0 + 1*0 + 0*1 + 1*0 + 0*1 + 1*1 | = | 1 |

U*H = | 0*1 + 1*1 + 0*1 + 1*0 + 0*0 + 1*1 + 0*0 + 1*1 | = | 3 |

| 0*0 + 1*1 + 0*0 + 1*1 + 0*1 + 1*1 + 0*0 + 1*0 | = | 3 |

| 0*1 + 1*0 + 0*1 + 1*1 + 0*1 + 1*1 + 0*1 + 1*0 | = | 2 |

| 1 | | 1 |

PR =| 3 | modulo 2 = | 1 |

| 3 | | 1 |

| 2 | | 0 |

U = [ 0 1 0 1 0 1 0 1 ] [ 1 1 1 0 ]

| 0*1 + 1*0 + 0*0 + 1*0 + 0*1 + 1*0 + 0*1 + 1*1 + 1*1 + 1*0 + 1*0 + 0*0 | = | 2 |

Uz*H = | 0*1 + 1*1 + 0*1 + 1*0 + 0*0 + 1*1 + 0*0 + 1*1 + 1*0 + 1*1 + 1*0 + 0*0 | = | 4 |

| 0*0 + 1*1 + 0*0 + 1*1 + 0*1 + 1*1 + 0*0 + 1*0 + 1*0 + 1*0 + 1*1 + 0*0 | = | 4 |

| 0*1 + 1*0 + 0*1 + 1*1 + 0*1 + 1*1 + 0*1 + 1*0 + 1*0 + 1*0 + 1*0 + 0*1 | = | 2 |

| 2 | | 0 |

PR =| 4 | modulo 2 = | 0 |

| 4 | | 0 |

| 2 | | 0 |

9. Poprawne zakodowanie litery `R':

R = [ 0 1 0 1 0 0 1 0 ]

| 0*1 + 1*0 + 0*0 + 1*0 + 0*1 + 0*0 + 1*1 + 0*1 | = | 1 |

R*H = | 0*1 + 1*1 + 0*1 + 1*0 + 0*0 + 0*1 + 1*0 + 0*1 | = | 1 |

| 0*0 + 1*1 + 0*0 + 1*1 + 0*1 + 0*1 + 1*0 + 0*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 1*1 + 0*1 + 0*1 + 1*1 + 0*0 | = | 2 |

| 1 | | 1 |

PR =| 1 | modulo 2 = | 1 |

| 2 | | 0 |

| 2 | | 0 |

R = [ 0 1 0 1 0 0 1 0 ] [ 1 1 0 0 ]

| 0*1 + 1*0 + 0*0 + 1*0 + 0*1 + 0*0 + 1*1 + 0*1 + 1*1 + 1*0 + 0*0 + 0*0 | = | 2 |

Rz*H = | 0*1 + 1*1 + 0*1 + 1*0 + 0*0 + 0*1 + 1*0 + 0*1 + 1*0 + 1*1 + 0*0 + 0*0 | = | 2 |

| 0*0 + 1*1 + 0*0 + 1*1 + 0*1 + 0*1 + 1*0 + 0*0 + 1*0 + 1*0 + 0*1 + 0*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 1*1 + 0*1 + 0*1 + 1*1 + 0*0 + 1*0 + 1*0 + 0*0 + 0*1 | = | 2 |

| 2 | | 0 |

PR =| 2 | modulo 2 = | 0 |

| 2 | | 0 |

| 2 | | 0 |

10. Poprawne zakodowanie litery `A':

A = [ 0 1 0 0 0 0 0 1 ]

| 0*1 + 1*0 + 0*0 + 0*0 + 0*1 + 0*0 + 0*1 + 1*1 | = | 1 |

A*H = | 0*1 + 1*1 + 0*1 + 0*0 + 0*0 + 0*1 + 0*0 + 1*1 | = | 2 |

| 0*0 + 1*1 + 0*0 + 0*1 + 0*1 + 0*1 + 0*0 + 1*0 | = | 1 |

| 0*1 + 1*0 + 0*1 + 0*1 + 0*1 + 0*1 + 0*1 + 1*0 | = | 0 |

| 1 | | 1 |

PR =| 2 | modulo 2 = | 0 |

| 1 | | 1 |

| 0 | | 0 |

A = [ 0 1 0 0 0 0 0 1 ][ 1 0 1 0 ]

| 0*1 + 1*0 + 0*0 + 0*0 + 0*1 + 0*0 + 0*1 + 1*1 + 1*1 + 0*0 + 1*0 + 0*0 | = | 2 |

Az*H = | 0*1 + 1*1 + 0*1 + 0*0 + 0*0 + 0*1 + 0*0 + 1*1 + 1*0 + 0*1 + 1*0 + 0*0 | = | 2 |

| 0*0 + 1*1 + 0*0 + 0*1 + 0*1 + 0*1 + 0*0 + 1*0 + 1*0 + 0*0 + 1*1 + 0*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 0*1 + 0*1 + 0*1 + 0*1 + 1*0 + 1*0 + 0*0 + 1*0 + 0*1 | = | 0 |

| 2 | | 0 |

PR =| 2 | modulo 2 = | 0 |

| 2 | | 0 |

| 0 | | 0 |

11. Poprawne zakodowanie litery `S':

S = [ 0 1 0 1 0 0 1 1 ]

| 0*1 + 1*0 + 0*0 + 1*0 + 0*1 + 0*0 + 1*1 + 1*1 | = | 2 |

S*H = | 0*1 + 1*1 + 0*1 + 1*0 + 0*0 + 0*1 + 1*0 + 1*1 | = | 2 |

| 0*0 + 1*1 + 0*0 + 1*1 + 0*1 + 0*1 + 1*0 + 1*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 1*1 + 0*1 + 0*1 + 1*1 + 1*0 | = | 2 |

| 2 | | 0 |

PR =| 2 | modulo 2 = | 0 |

| 2 | | 0 |

| 2 | | 0 |

S = [ 0 1 0 1 0 0 1 1 ] [ 0 0 0 0 ]

| 0*1 + 1*0 + 0*0 + 1*0 + 0*1 + 0*0 + 1*1 + 1*1 + 0*1 + 0*0 + 0*0 + 0*0 | = | 2 |

Sz*H = | 0*1 + 1*1 + 0*1 + 1*0 + 0*0 + 0*1 + 1*0 + 1*1 + 0*0 + 0*1 + 0*0 + 0*0 | = | 2 |

| 0*0 + 1*1 + 0*0 + 1*1 + 0*1 + 0*1 + 1*0 + 1*0 + 0*0 + 0*0 + 0*1 + 0*0 | = | 2 |

| 0*1 + 1*0 + 0*1 + 1*1 + 0*1 + 0*1 + 1*1 + 1*0 + 0*0 + 0*0 + 0*0 + 0*1 | = | 2 |

| 0 | | 0 |

PR =| 0 | modulo 2 = | 0 |

| 0 | | 0 |

| 0 | | 0 |

12. Poprawne zakodowanie litery `Z':

Z = [ 0 1 0 1 1 0 1 0 ]

| 0*1 + 1*0 + 0*0 + 1*0 + 1*1 + 0*0 + 1*1 + 0*1 | = | 2 |

Z*H = | 0*1 + 1*1 + 0*1 + 1*0 + 1*0 + 0*1 + 1*0 + 0*1 | = | 1 |

| 0*0 + 1*1 + 0*0 + 1*1 + 1*1 + 0*1 + 1*0 + 0*0 | = | 3 |

| 0*1 + 1*0 + 0*1 + 1*1 + 1*1 + 0*1 + 1*1 + 0*0 | = | 3 |

| 2 | | 0 |

PR =| 1 | modulo 2 = | 1 |

| 3 | | 1 |

| 3 | | 1 |

Z = [ 0 1 0 1 1 0 1 0 ] [ 0 1 1 1 ]

| 0*1 + 1*0 + 0*0 + 1*0 + 1*1 + 0*0 + 1*1 + 0*1 + 0*1 + 1*0 + 1*0 + 1*0 | = | 2 |

Zz*H = | 0*1 + 1*1 + 0*1 + 1*0 + 1*0 + 0*1 + 1*0 + 0*1 + 0*0 + 1*1 + 1*0 + 1*0 | = | 2 |

| 0*0 + 1*1 + 0*0 + 1*1 + 1*1 + 0*1 + 1*0 + 0*0 + 0*0 + 1*0 + 1*1 + 1*0 | = | 4 |

| 0*1 + 1*0 + 0*1 + 1*1 + 1*1 + 0*1 + 1*1 + 0*0 + 0*0 + 1*0 + 1*0 + 1*1 | = | 4 |

| 2 | | 0 |

PR = | 2 | modulo 2 = | 0 |

| 4 | | 0 |

| 4 | | 0 |

13. Celowo uszkadzamy teraz kod w 6 kolumnie zapisu binarnego zmieniając wartość na przeciwną, po czym otrzymujemy:

R = [ 0 1 0 1 0 0 1 0 ][ 1 1 0 0 ] -> V = [ 0 1 0 1 0 1 1 0 ][ 1 1 0 0 ]

Teraz nasza litera `R' stała się literą `V'. By odnaleźć prawdziwą wartość ponownie wykonujemy powyższe czynności.

| 0*1 + 1*0 + 0*0 + 1*0 + 0*1 + 1*0 + 1*1 + 0*1 + 1*1 + 1*0 + 0*0 + 0*0 | = | 2 |

Vz*H = | 0*1 + 1*1 + 0*1 + 1*0 + 0*0 + 1*1 + 1*0 + 0*1 + 1*0 + 1*1 + 0*0 + 0*0 | = | 3 |

| 0*0 + 1*1 + 0*0 + 1*1 + 0*1 + 1*1 + 1*0 + 0*0 + 1*0 + 1*0 + 0*1 + 0*0 | = | 3 |

| 0*1 + 1*0 + 0*1 + 1*1 + 0*1 + 1*1 + 1*1 + 0*0 + 1*0 + 1*0 + 0*0 + 0*1 | = | 3 |

| 2 | | 0 |

PR = | 3 | modulo 2 = | 1 |

| 3 | | 1 |

| 3 | | 1 |

Powyższa wartość jest różna od 0, więc musimy przyrównać wynik do kolumny z macierzy H, by dowiedzieć się z której kolumnie wystąpił błąd:

| 0 |

| 1 | = PR

| 1 |

| 1 |

| 1 0 0 0 1 0 1 1 | 1 0 0 0 |

| 1 1 1 0 0 1 0 1 | 0 1 0 0 | = H

| 0 1 0 1 1 1 0 0 | 0 0 1 0 |

| 1 0 1 1 1 1 1 0 | 0 0 0 1 |

Jak widać powyżej, kolumna PR jest równa kolumnie 6, więc błąd leży w 6 bicie zakodowanej wartości, dlatego należy zmienić jego wartość na przeciwną.

VI. Tablice z wynikami otrzymanymi podczas badań.

================================================================

Podaj tekst ktory chcesz zakodowac.

Pamietaj, mozesz uzyc tylko duzych liter, bez polskich znakow.

Wpisz maksymalnie 20 znaków.

[ @ ] WPISZ TEKST: AREK KURASZ

[ @ ] Zakodowany i uszkodzony napis to: AVEK KURASZ

blad w zapisie litery nr 1, w 6 kolumnie zapisu BIN. Poprawiono blad.

blad w zapisie litery nr 2, w 7 kolumnie zapisu BIN. Poprawiono blad.

[ @ ] Odkodowany i poprawiony napis to: AREK KURASZ

================================================================

VII. Wykresy sporządzone w oparciu o wyniki pomiarowe.

W tym ćwiczeniu wykresy nie były sporządzane.

VIII. Wnioski sporządzone na podstawie wykonanych badań.

Dzięki opracowaniu kodu Hamminga, który poprzez dodanie do wiadomości dodatkowych symboli, jesteśmy w stanie w łatwy sposób wykryć i skorygować błędy polegające na przekłamaniu któregoś z bitów. Wykonane obliczenia potwierdziły teorie. W łatwy sposób jesteśmy w stanie odszyfrować wiadomość, sprawdzić jej poprawność i w razie błędu szybko skorygować. Program kodujący przygotowany pod Matlab poprawnie zakodował oraz rozkodował wprowadzony tekst, poprawiając wykryte błędy.

IX. Literatura

• www.wikipedia.pl

• Materiały udostępnione przez p. mgr inż. Małgorzata Zygarlicka

X. Załącznik - Protokół z pomiarów

Brak załączników.

SPRAWOZDANIE Lab. 1 Kodowanie nadmiarowe - kod Hamminga

6 | Strona

POLITECHNIKA OPOLSKA

WYDZIAŁ ELEKTROTECHNIKI, AUTOMATYKI I INFORMATYKI

---