UNIVERZITET U NOVOM SADUFAKULTET TEHNIČKIH NAUKANOVI SADOdsek/smer/usmerenje: Računarstvo i automatika/Računarske nauke i informatika

SEMINARSKI RAD

Kandidat: Žolt KanjoBroj indeksa: E 13645

Tema rada: Detekcija i korekcija grešaka u signalima

Mentor rada: dr Aleksandar Kovačević

Mesto i datum:

Novi Sad 2013.

ZADATAK SEMINARSKOG RADA

Zadatak seminatskog rada je prezentacija detekcije i korekcije grešaka u signalima pri prenosu i čuvanju podataka. Razjašnjenje metode Hemingovog i CRC kodiranja. Funkcionisanje metoda treba pokazati na pimeru. Za testiranje Hemingovog koda uraditi kodiranje slike, generisanje slučajnih grešaka u kodu za simulaciju prenosa pa potom dekodiranje i sa tim oporavak slike od grešaka.

SADRŽAJ

1. UVOD..............................................................................................11.1. Onovna podela..........................................................................1

2. HEMINGOVI KODOVI..................................................................32.1. Kodiranje..................................................................................3

2.1.1. Generisanje kodne reči i njeno popunjavanje bitovima podataka.......................................................................................32.1.2. Računanje vrednosti bitova parnosti..................................4

2.2. Dekodiranje...............................................................................52.2.1. Određivanje mesta greške..................................................52.2.2. Korigovanje greške............................................................72.2.3. Formiranje izlaznih podataka.............................................7

2.3. Primer prenosa slike..................................................................82.3.1. Kodiranje slike...................................................................82.3.2. Simulacija grešaka pri prenosu........................................102.3.3. Dekodiranje slike.............................................................13

2.4. Opšte karakteristike................................................................143.CRC KODIRANJE.........................................................................17

3.1. Implementacija........................................................................173.2.Kodiranje.................................................................................17

3.2.1. Odabir polinom generatora..............................................183.2.2. Deljenje polinoma............................................................183.2.3. Dodavanje koeficijenata..................................................19

3.3. Dekodiranje.............................................................................193.4. Primer......................................................................................21

4. ZAKLJUČAK................................................................................23LITERATURA..................................................................................25BIOGRAFIJA....................................................................................27

1. UVODDetekcija i korekcija greške ima veliki pratičan značaj u

obezbeđivanju integriteta podataka tokom prenosa ili čuvanja na nepouzdanom memorijskom mediju.

1.1. Onovna podelaU opštem slučaju postoje dva pristupa:

1. Kontrola greške unapred (FEC - Forward error correction), u kome svaki karakter ili blok podataka koji se šalje sadrži dodatne (redundantne) informacije. Na osnovu ovih informacija primalac može ne samo da otkrije postojanje greške, već i da odredi koji su bitovi u primljenom podatku pogrešni i da grešku ukloni negacijom pogrešnih bitova. Ovde spada Hemingov kod.

2. Kontrola greške unatrag (ARQ - Automatic Repeat-reQuest), odnosno kontrola sa povratnom spregom. U ovom slučaju svaki karakter ili blok podataka koji se šalje sadrži samo neophodne dodatne informacije koje omogućuju primaocu da otkrije prisustvo greške, ali ne i mesto na kome se ona nalazi. U tom slučaju jedini način za dobijanje korektnih podataka je ponavljanje prenosa svih karaktera ili blokova podataka koji imaju grešku. Na primer CRC kodovanje.

U praksi, broj dodatnih bitova brzo raste sa porastom dužine podataka koji se prenose. Posledica toga je:

1. Metod sa kontrolom greške unatrag se najčešće koristi u telekomunikaconom prenosu podataka.

2. Metod sa kontrolom greške unapred se češće koristi pri čuvanju podataka na memorijskim medijumima u računarskom sistemu.

1

2. HEMINGOVI KODOVI Najčešći tipovi kodova za korekciju grešaka kod RAM-ova su

Hemingovi kodovi. Kod Hemingovog koda n-tobitnoj reči dodaje se k bitova parnosti i formira nova reč od m=n+k bitova. Bitovi u sekvenci su numerisani počev od 1 do m. Bitovi parnosti se uvek nalaze na pozicijama 1, 2, 4, 8, ... , 2m-1, tj. na bit pozicijama stepena dva. Ostali bitovi su bitovi podataka.

Kod se može koristiti za reč proizvoljne dužine. U opštem slučaju, vrednost svakog bita parnosti se bira tako da je ukupan broj jedinica u specifičnoj grupi bit pozicija paran, a grupe su tako odabrane da se informacioni bit ne pokriva od strane iste kombinacije bitova parnosti. Preciznije kazano, svaki bit parnosti na poziciji 2p, 0 ≤ p ≤ m-1 prati odgovarajuća grupa informacionih bitova koja uključuje sve one bitove na pozicijama čija binarna predstava ima 1 na poziciji 2p.

Slika 2.1. Vizuelni prikaz organizacije bitova parnosti i podataka Hemingovog koda

2.1. Kodiranje

2.1.1. Generisanje kodne reči i njeno popunjavanje bitovima podataka

Primer karakteristike Hemingovog koda na 8-bitne reči 1100 0100.Uvode se četiri bita parnosti, pa je 12 bitova uređeno na sledeći način:

Pozicija 1 2 3 4 5 6 7 8 9 10 11 12Kod P1 P2 1 P4 1 0 0 P8 0 1 0 0

3

Realizacija u matlab-u:

code=zeros(1,m);for i=1:m if(i ~= 2^k1) % provera da li je tekuca lokacija bit %podataka code(i)=data(n1); n1 = n1+1; else k1 = k1+1; endend

Gde su ulazi u korak: vektor data, dužine n koja sadrži sve bitove podataka m - zbir bitova podataka i parnosti (n+k) n1 - tekući bit podataka, na početku koraka je jedan k1 - tekući bit parnosti, na početku koraka je nula

Izlaz iz ovog koraka je vektor code, dužine m, čiji su još bitovi parnosti sve nule.

Korak prođe kroz svaki bit novog vektora code i svakom bitu koji nije bit parnosti dodeli jedan bit podataka.

2.1.2. Računanje vrednosti bitova parnosti

Svaki bit parnosti se izračunava na sledeći način:P1=ExOR bitova (3, 5, 7, 9, 11) = 1 1 0 0 0 = 0P2=ExOR bitova (3, 6, 7, 10, 11) = 1 0 0 1 0 = 0P4=ExOR bitova (5, 6, 7, 12) = 1 0 0 0 = 1P8=ExOR bitova (9, 10, 11, 12) = 0 1 0 0 = 1

gde ExOR predstavlja logičku isključivo ILI operaciju.

Zamenom vrednosti za P1, P2, P4 i P8 dobijamo sledeću 12-tobitnu informaciju.

Pozicija 1 2 3 4 5 6 7 8 9 10 11 12Kod 0 0 1 1 1 0 0 1 0 1 0 0

4

Realizacija ovog zadatka u matlab-u:for i=1:m if(i == 2^k1) % provera da li je tekuca lokacija bit %parnosti k1=k1+1; for j= i+1:m pozicija = fliplr(dec2bin(j,k)); if(pozicija(k1) == '1') code(i)=xor(code(i),code(j)); end end endendGde su ulazi u korak:

vektor code, dužine m, koji sadrži sve bitove podataka, a na pozicijama bitova parnosti su mu sve nule

k - broj bitova parnosti m - zbir bitova podataka i parnosti (n+k) k1 - tekući bit parnosti, na početku koraka je nula

Izlaz iz ovog koraka je sam Hemingov kod u obliku vektora code, dužine m.Korak prođe kroz svaki bit parnosti i njihovu vrednost izračuna tako

što sabere (binarno bez prenosa,što je u suštini ExOR operacija) sve bitove podataka od kojih on zavisi (vidi sliku 2.1, gde X-ovi označavaju zavisnost).

2.2. Dekodiranje

2.2.1. Određivanje mesta greške

12-bitna informacija se nakon kodiranja, recimo, upisuje u memoriju. Kada se 12-bitna informacija pročita iz memorije ponovo se vrši provera radi grešaka. Proverava se parnost reči nad istom grupom bitova uključujući i bit parnosti. Sva četiri bita se proveravaju na sledeći način:

C1 = ExOR bitova (1, 3, 5, 7, 9, 11)C2 = ExOR bitova (2, 3, 6, 7, 10, 11)C4 = ExOR bitova (4, 5, 6, 7, 12)C8 = ExOR bitova (8, 9, 10, 11, 12)

S obzirom da su u konkretnom slučaju bitovi upisani sa parnom parnošću, vrednost rezultata C= C8C4C2C1 = 0000 ukazuje da do greške nije

5

došlo. U slučaju kada se javi jednostruka greška nakon provere dobićemo C≠0 pa je tada na osnovu sadržaja 4-bitnog binarnog broja koga formiraju bitovi provere moguće tačno odrediti pogrešnu bit poziciju. Primera radi, posmatrajmo sledeća tri slučaja.

Pozicija: 1 2 3 4 5 6 7 8 9 10 11 120 0 1 1 1 0 0 1 0 1 0 01 0 1 1 1 0 0 1 0 1 0 00 0 1 1 0 0 0 1 0 1 0 0

U prvom slučaju ne postoji greška, u drugom došlo je do promene bit pozicije 1 sa 0 na 1, a u trećem do promene bit pozicije 5 sa 1 na 0. Na osnovu sadržaja bitova C8, C4, C2, i C1 moguće je tačno odrediti mesto gde se javila greška, srodno sledećoj tabeli:

C8 C4 C2 C1 Bit pozicija greške0 0 0 0 nema greške0 0 0 1 10 1 0 1 5

Realizacija u matlab-u:for i=1:m if(i == 2^k1) % provera da li je tekuca lokacija bit %parnosti k1=k1+1; temp=0; for j= i+1:m pozicija = fliplr(dec2bin(j,k)); if(pozicija(k1) == '1') temp=xor(temp,code(j)); end end if(temp~=code(i)) flag = 2; greska = greska + i; end endend

Gde su ulazi u korak:

6

vektor code, koji je sam Hemingov kod, dužine m k - broj bitova parnosti m - zbir bitova podataka i parnosti (n+k) k1 - tekući bit parnosti, na početku koraka je nula

Izlaz iz ovog koraka je greska (na početku koraka je nula), šta označava poziciju greške u code-u.

Korak izračuna vrednost svakog bita parnosti, kao što je opisano u kodiranju, i uporedi dobijenu vrednost sa odgovarajućom vrednošću na toj poziciji u vektoru code, ako razliku znači da se desila greška pri prenosu/čuvanju podataka na jednoj od lokacija od koje je zavisna tekući bit parnosti. Sabiranjem lokacija bitova parnosti kod kojih se desila greška dobijemo poziciju na kojoj se zapravo desila greška pri prenosu/čuvanju podatka.

2.2.2. Korigovanje greške

Greška se može korigovati komplementiranjem vrednosti odgovarajućeg bita. Treba istaći da se greška može ravnopravno javiti kako u bitovima za podatke tako i u bitovima za proveru parnosti.

if(greska>0) if(greska>length(code)) code(greska) = 0; end code(greska)= ~code(greska);end

Gde su ulazi u korak: vektor code, koji je sam Hemingov kod, dužine m greška, koja označava poziciju na kojoj se desila greška

Izlaz iz ovog koraka je ispravan vektor code, ako je korekcija bila moguća, tj. ako se desila najviše jedna bit promena pri prenosu.

Korak negira bit na poziciji greška ako je ona veća od nule.

2.2.3. Formiranje izlaznih podataka

Posle ispravke nam ostane jedino da izdvojimo bitove podataka iz code-a, tj. da eliminišemo bitove parnosti. To možemo uraditi na sledeći način.

for i=1:m if(i ~= 2^k1) % provera da li je tekuca lokacija bit %podataka

7

data(n1)=code(i); n1 = n1+1; else k1 = k1+1; endendGde su ulazi u korak:

vektor code, dužine m koji predstavlja ispravljen kod m - zbir bitova podataka i parnosti (n+k) n1 - tekući bit podataka, na početku koraka je jedan k1 - tekući bit parnosti, na početku koraka je nula

Izlaz iz ovog koraka je vektor data, dužine n, koji predstavlja podatak koji smo pre prenosa kodirali.

2.3. Primer prenosa slikeZadatak je da jednu proizvoljnu sliku kodiramo Hemingovim

kodiranjem, potom simuliramo njen prenos ili čuvanje na nesigurnom memorijskom medijumu, pri čemu se pojave slučajne greške, pa da ispravimo te greške dekodiranjem Hemingovog koda.

2.3.1. Kodiranje slike

Da bi sliku mogli kodirati treba da ga prvo pretvorimo u matrični oblik. Za to ćemo koristiti matlabovu imread funkciju.

slika = imread('slika.jpg');Tako ćemo dobiti matricu slika koja je trodimenzionalna, pošto je

reč o slici sa ekstenzijum jpg. Dimenzije su širina slike u pikselima, visina slike u pixelima i dubina u smislu RGB skale, tj. treći parametar matrice slika će uzimati vrednosti od 1 do 3 u zavisnosti od toga koju boju posmatramo. Svi elementi matrice su 8-bitne vrednosti (od 1 do 255).

Za kodiranje ćemo korisiti novi matricu kodiranaslika u koju ćemo preslikati matricu slika Hemingovim kodiranjem. Za to treba da pretvorimo svaki (decimalni) element matrice slika u binarni vektor, koji prosledimo funkciji hammingCoding. Funcija vraća hemingov kod, koji još treba samo da vratimo u decimalni oblik, i da sačuvamo u odgovarajuću lokaciju matrice kodiranaslika.

8

[n,m,o]=size(slika);kodiranaslika=zeros(n,m,o);%popunjavanje nove matrice kodiranim vrednostimafor i=1:o for j=1:m for k=1:n%konvertujemo iz dekadnog u binarni broj,s tim da ga %moramo obrnuti sa fliplr funkcijom binarno=(fliplr(dec2bin(slika(k,j,i))))-'0'; %kodiramo ga

kod=hammingCoding(binarno); %upisemo ga u novu matricukodiranaslika(k,j,i)=bin2dec(fliplr(sprintf('%d',kod))); end endend

Simuliraćemo prenos jedne proizvoljne slike:

9

Za demonstraciju kodiranja ćemo posmatrati deo matrice slika:

100 100 99 99 100 101 101 101 102 103 103102 101 99 98 98 100 101 102 102 103 10399 101 102 102 101 100 100 100 100 102 10399 101 103 103 101 100 99 100 101 102 103102 102 102 100 99 100 102 104 104 104 105102 102 102 101 101 101 102 103 104 104 105101 102 103 104 104 103 102 101 103 104 105103 103 103 104 104 103 102 102 105 105 106104 103 102 101 102 103 104 106 105 106 10799 100 101 102 105 105 106 105 106 107 107102 101 103 103 104 105 106 106 105 105 106

Pa posle kodiranja matrice isti deo matrice kodiranaslika izgleda ovako:

1579 1579 1567 1567 1579 1580 1580 1580 1586 1589 15891586 1580 1567 1560 1560 1579 1580 1586 1586 1589 15891567 1580 1586 1586 1580 1579 1579 1579 1579 1586 15891567 1580 1589 1589 1580 1579 1567 1579 1580 1586 15891586 1586 1586 1579 1567 1579 1586 1610 1610 1610 16131586 1586 1586 1580 1580 1580 1586 1589 1610 1610 16131580 1586 1589 1610 1610 1589 1586 1580 1589 1610 16131589 1589 1589 1610 1610 1589 1586 1586 1613 1613 16191610 1589 1586 1580 1586 1589 1610 1619 1613 1619 16201567 1579 1580 1586 1613 1613 1619 1613 1619 1620 16201586 1580 1589 1589 1610 1613 1619 1619 1613 1613 1619

2.3.2. Simulacija grešaka pri prenosu

U nekim slučajno izabranim elementima matrice kodiranaslika generišemo grešku na sledeći način. Za to treba da pretvorimo neke (decimalne) elemente matrice dekodiranaslika u binarni vektor, čiji nasumično izabrani bit negiramo. Posle treba samo da vratimo elemente u decimalni oblik, i da sačuvamo u odgovarajuću lokaciju matrice kodiranaslika.

10

%generisemo slucajne greske kao posledice prenosafor i=1:o for j=1:korak1:m for k=1:korak2:n%iscitamo broj iz nove matrice,i odmah pretvorimo u %binarni broj

binarno=(dec2bin(kodiranaslika(k,j,i)))-'0'; r=randi([1,length(binarno)]); %kao slucajnu gresku izmenimo r-tu lokaciju binarnog %vektora binarno(r)=~binarno(r);kodiranaslika(k,j,i)=bin2dec(sprintf('%d',binarno)); end endend

Gde korak1 i korak2 predstavljaju korake, npr ako je korak1=korak2=5, to znači da će algoritam izmeniti 1 bit elementa u svakoj petoj koloni i u svakom petom redu matrice. Ako pokrenemo algoritam ponovo sa korak1=5 a korak2=40 izazvaćemo još jednu bit grešku u svakom četrdesetom redu, pa će deo matrice kodiranaslika izgledati ovako (s tim da se dvobitna greška desila u prvom redu posmatranog dela matrice, a jednobitne greške u svakom narednom petom redu):

1582 1579 1567 1567 1579 1838 1580 1580 1586 1589 16851586 1580 1567 1560 1560 1579 1580 1586 1586 1589 15891567 1580 1586 1586 1580 1579 1579 1579 1579 1586 15891567 1580 1589 1589 1580 1579 1567 1579 1580 1586 15891586 1586 1586 1579 1567 1579 1586 1610 1610 1610 16131074 1586 1586 1580 1580 1708 1586 1589 1610 1610 5891580 1586 1589 1610 1610 1589 1586 1580 1589 1610 16131589 1589 1589 1610 1610 1589 1586 1586 1613 1613 16191610 1589 1586 1580 1586 1589 1610 1619 1613 1619 16201567 1579 1580 1586 1613 1613 1619 1613 1619 1620 16201590 1580 1589 1589 1610 1612 1619 1619 1613 1613 1618

11

E sad ako iz elemenata ove matrice eliminišemo bitova parnosti, ali bez korigovanja bitova podataka dobijemo sledeći deo matrice:

101 100 99 99 100 117 101 101 102 103 99102 101 99 98 98 100 101 102 102 103 10399 101 102 102 101 100 100 100 100 102 10399 101 103 103 101 100 99 100 101 102 103102 102 102 100 99 100 102 104 104 104 10570 102 102 101 101 101 102 103 104 104 41101 102 103 104 104 103 102 101 103 104 105103 103 103 104 104 103 102 102 105 105 106104 103 102 101 102 103 104 106 105 106 10799 100 101 102 105 105 106 105 106 107 107103 101 103 103 104 105 106 106 105 105 106

A odavde se vidi da ova matrica razlikuje od matrice slika u onim elementima gde se greška desila u bitovima podataka, a ne u bitovima parnosti. Dobijena slika sa greškama izgleda ovako.

12

2.3.3. Dekodiranje slike

Sliku posle prenosa treba dekodirati i sa tim otkloniti greške. Generišemo novu matricu dekodiranaslika sa istim dimenzijama kao što je kodiranaslika, u koju ćemo preslikato je.

Za to treba da pretvorimo svaki (decimalni) element matrice kodiranaslika u binarni vektor, koji prosledimo funkciji hammingDecoding. Funcija vraća binarni vektor podataka koji smo imali pre prenosa,i koji još treba samo da vratimo u decimalni oblik, i da sačuvamo u odgovarajuću lokaciju matrice dekodiranaslika. Funkcija hammingDecoding će izvršiti korekciju grešaka.

dekodiranaslika=uint8(zeros(n,m,o));%dekodiranje sadrzaja nove matrice sa ispravkama %gresaka, i popunjavanje trece matricefor i=1:o for j=1:m for k=1:nbinarno=(fliplr(dec2bin(kodiranaslika(k,j,i),12)))-'0'; piksel=hammingDecoding(binarno); dekodiranaslika(k,j,i)=bin2dec(fliplr(sprintf('%d',piksel))); end endend

Posle dekodiranja deo matrice dekodiranaslika izgleda ovako:

101 100 99 99 100 53 101 101 102 103 99102 101 99 98 98 100 101 102 102 103 10399 101 102 102 101 100 100 100 100 102 10399 101 103 103 101 100 99 100 101 102 103102 102 102 100 99 100 102 104 104 104 105102 102 102 101 101 101 102 103 104 104 105101 102 103 104 104 103 102 101 103 104 105103 103 103 104 104 103 102 102 105 105 106104 103 102 101 102 103 104 106 105 106 10799 100 101 102 105 105 106 105 106 107 107102 101 103 103 104 105 106 106 105 105 106

A sliku možemo prikazati sa funkcijom image.

image(dekodiranaslika);

13

Zaključak: Hemingova metoda (de)kodiranja je uspešno ispravila sve jednobitne greške.

2.4. Opšte karakteristikeHemingov kod se može koristiti za podatke bilo koje dužine. U

opštem slučaju, za k bitova provere i n bitova podataka, ukupan broj bitova, n + k, koji se u reči može kodirati je najviše 2k - 1. Drugim rečima, mora da se sačuva odnos n + k = 2k - 1. Na osnovu ovog odnosa se dobija da je broj bitova u reči n ≤ 2k – 1 - k. Na primer, za k = 3, ukupan broj bitova u kodnoj reči iznosi n + k = 23 - 1 = 7, što daje n ≤ 7 - 3 = 4. Za k = 4, imamo n + k ≤ 15 što daje n ≤ 11. To znači da reč podatka može da ima manje od 11 bitova, ali mora da ima najmanje 5 bitova; ako ne, potrebna su samo tri bita provere.

Osnovni Hemingov kod može da detektuje i koriguje jednostruku grešku. Neke višestruke greške se mogu detektovati, ali se ne mogu ispravno korigovati kao što je to bio slučaj sa jednostrukim greškama. Dodavanjem još jednog bita parnosti kodnoj reči Hemingov kod se može koristiti za korekciju jednostrukih grešaka a detekciju dvostrukih. Uvođenjem dodatnog bita parnosti, prethodna 12-tobitno kodirana reč postaje 001110010100P13, gde P13 predstavlja ExOR operaciju nad ostalih 12 bitova. Na ovaj način se dobija 13-bitna reč 001110010001 (parna parnost). Kada se ova reč čita iz memorije, bitovi provere, a takođe i bit

14

parnosti P, se određuju nad svih 13 bitova. Ako je P=0, parnost je korektna (parna parnost), ali ako je P=1 parnost kod svih 13 bitova nije korektna. Pri ovome se mogu javiti sledeća četiri slučaja:

a) ako je C=0 i P=0 ne postoji greškab) ako je C≠0 i P=1 postoji jednostruka greška koja se može

korigovatic) ako je C≠0 i P=0 detektovana je dvostruka greška ali se ne

može korigovatid) ako je C=0 i P=1 javila se greška na bit poziciji P13.

15

3.CRC KODIRANJE

Metoda cikličke provere redundanci (eng. Cyclic Redundancy Checking, CRC) se koristi za otkrivanje proširenih grešaka. CRC može da otkrije bilo koji neparan broj grešaka, sve 2-bitne greške, kao i proširene greške čija je dužina manja od broja redundantnih bitova.

3.1. Implementacija

CRC može da se implementira hardverski. Zasnovana je na:1. Aritmetici u polju celih brojeva po modulu 2. U toj aritmetici

nema prenosa pri operaciji sabiranja niti pozajmice sa prethodnog mesta pri operaciji oduzimanja. Tako za sabiranje važi 0 + 0 = 1 + 1 = 0, 0 + 1 = 1 + 0 = 1, 1-1 = 0-0 = 0, 0-1 = 1-0 = 1; slična pravila važe i za množenje I deljenje.

2. Deljenju polinoma, pri čemu se i ovo deljenje izvodi u aritmetici po modulu

U CRC metodi niz bitova se posmatra kao niz koeficijenata polinoma. Tako niz bitova an an-1 … a1 a0 odgovara polinomu M(x) = anxn + an-1xn-1 + … + a1x + a0.

Na primer:11100110 M(x) = x7 + x6 + x5 + x2 + x1

11001 M(x) = x4 + x3 + 1

3.2.Kodiranje

Osnovni koraci:

1. Odabrati polinom generator G(x)2. Podeliti polinome xkM(x)/G(x) 3. Dodati koeficijente ostatka na kraj poruke i poruku proslediti

primaocu.

17

3.2.1. Odabir polinom generatora

Ovo je stvar dogovora posaljioca i primaoca. Što je G(x) većeg reda, to su veće šanse da otkrije proširene greške u dužem nizu podataka. G(x) mora biti manjeg reda od M(x). Neki popularni polinom generatori su:

CRC-16: x16 + x15 + x2 + 1CRC-CCITT: x16 + x12 + x5 + 1

CRC-CCITT: x32+x26+x23+x16+x12+x11+x10+x8+x7+x5+x4+x2+1

3.2.2. Deljenje polinoma

Treba izračunati xkM(x)/G(x), dodavanjem k nula na kraj polinoma M(x) i podelom dobijenog polinoma sa G(x) deljenjem po modulu 2 bez pozajmice, gde je k stepen polinoma G(x). Dobijeni ostatak se označava sa R(x).

Realizacija u matlabu:

1. Prvi korak je množenje M(x) sa xk i eliminacija vodećih nula.

R=[data zeros(1,k)];%treba da eliminisemo vodece nule iz nizawhile(length(R)>k) if(R(1)==0) R(1)=[]; else break; endendGde su ulazi u korak:

vektor data, predstavlja ulazni podatak, dužine n k – red polinom generatora G(x)

Izlaz iz ovog koraka je vektor R, šta predstavlja deljenik deljenja polinoma.

Korak dodaje k nula na kraj deljenika i eliminiše vodeće nule sa poćetka niza, što je neophodno za ispravno funkcionisanje algoritma u drugom koraku.

18

2. Drugi korak je deljenje

%deljenje po modulu dva bez prenosaG=[G zeros(1,length(R)-length(G))];while(length(R)>k) R=xor(R,G); while(length(R)>k) if(R(1)==0) R(1)=[]; else break; end end G=G(1:length(R));endGde su ulazi u korak:

polinom R, predstavlja deljenik polinom G, predstavlja delilac k – red polinom generatora G(x)

Izlaz iz ovog koraka je vektor R, šta predstavlja ostatak pri deljenju, dužine k.

Korak dodaje toliko nule na kraj delilaca da postane iste dužine kao R, da bi pojednostavnio algoritam deljenja. Potom uradio XOR operaciju nad R sa maskom G, eliminiše vodeće nule sa početka polinoma R i nule sa kraja G, toliko da bude iste dužine kao R. Ovo sve ponavlja dok R ne bude dužine k.

3.2.3. Dodavanje koeficijenata

Nakon deljenja treba da dodajem koeficijente ostatka deljenja na kraj ulaznog podatka i tako dobijemo izlazni CRC kod.

code = [data R];

3.3. Dekodiranje

Za dekodiranje treba da podelimo primljenu polinomijalnu kodnu reč (CRC kod) sa G(x), deljenjem po modulu 2 bez pozajmice. Ako je ostatak deljenja nula, nema grešaka pri prenosu. Ako ostatak deljenja nije nula, greške pri prenosu postoje.

19

Realizacija u matlab-u:

R=code;%eliminisanje vodecih nula iz nizawhile(length(R)>k-1) if(R(1)==0) R(1)=[]; else break; endendG=[G zeros(1,length(R)-length(G))]; %deljenje po modulu dva bez prenosawhile(length(R)>k-1) R=xor(R,G); while(length(R)>k-1) if(R(1)==0) R(1)=[]; else break; end end G=G(1:length(R));enddata=code(1:n);if(sum(R)~=0) flag=2;end

Deljenje se u suštini radi isto kao kod kodiranja, s tim što polinom R na početku algoritma predstavlja primljenu polinomijalnu kodnu reč (CRC kod) i ne treba ga množiti sa xk.

Ako je suma koeficijenata ostatka pri deljenju R nije nula, to znači da se desila greška pri prenosu i izlazni podaci dekodiranja su neispravni, u tom slučaju postavi flag na neku vrednost različitu od nule šta u praksi izaziva ponovno slanje podatka, pošto kod CRC kodiranja nemamo mogućnost na korigovanje grešaka.

20

3.4. Primer

Primer:Neka je niz bitova 11100110, polinom generator G(x) = x4 + x3 + 1.Dodajemo 4 nule (tj. množimo sa x4) i delimo:

1 1 1 0 0 1 1 0 0 0 0 0- 1 1 0 0 1

1 0 1 1 1 0 0 0 0 0- 1 1 0 0 1

1 1 1 0 0 0 0 0 0- 1 1 0 0 1

1 0 1 0 0 0 0- 1 1 0 0 1

1 1 0 1 0 0- 1 1 0 0 1

1 1 0

Sada na orginalan niz dodajemo ostatak 0110 (vodimo računa da to budu 4 bita), pa je rezultat: 111001100110

Pa posle prenosa proverimo:1 1 1 0 0 1 1 0 0 1 1 0

- 1 1 0 0 11 0 1 1 1 0 0 1 1 0

- 1 1 0 0 11 1 1 0 0 0 1 1 0

- 1 1 0 0 11 0 1 0 1 1 0

- 1 1 0 0 11 1 0 0 1 0

- 1 1 0 0 10

Ostatak je 0, dakle nema greške pri prenosu.

21

Sada pretpostavimo da se pri prenosu desi greška na bitu 4. Provera za taj slučaj:

1 1 1 1 0 1 1 0 0 1 1 0- 1 1 0 1 1

1 1 1 1 1 0 0 1 1 0- 1 1 0 0 1

1 1 0 0 0 1 1 0- 1 1 0 0 1

1 1 1 0

Ostatak nije 0, dakle detektovali smo grešku.

22

4. ZAKLJUČAKDetekcija i korekcija grešaka u signalima predstavlja važan deo

prenosa i čuvanja podataka, bez čega ne bi mogao da funkcioniše elektronska komunikacija i čuvanje podataka na medijumima, zbog mogućnosti postojanja grešaka. Odgovarajuću metodu za detekciju i korekciju grešaka treba izabrati u skladu sa verovatnoćom postojanja greške i sa dužinom blokova podataka.

23

LITERATURA

[1] Otkrivanje i korekcija grešaka, http://poincare.matf.bg.ac.rs/~zstanic/uor/Slajdovi/06.greske.pdf

[2] Uvod u organizaciju računara, Otkrivanje i korekcija grešakahttp://poincare.matf.bg.ac.rs/~danijela/UOR/12_cas1.pdf

[3] 4. Kodiranje, detekcija i korekcija grešaka, http://starisajt.elfak.ni.ac.rs/phptest/new/html/informacije/vesti/resenja/mps/poglavlja/stojcev/digitalna%20elektronika/Glava4.pdf

25

BIOGRAFIJAŽolt Kanjo je rođen 12.01.1991. godine u Somboru. Osnovnu školu

„Bratstvo Jedinstvo“ završio je 2006. godine. Srednju Tehničku školu u Somboru završio je 2010. godine. Iste godine upisao se na Fakultet tehničkih nauka, odsek Računarstvo i automatika. Školske 2012/2013. godine upisao se na smer Računarske nauke i informatika.

27