Codifica di Reed-Solomon per un modem digitale a 64 kbps in

Transcript

Codifica di Reed-Solomon per un modem digitale a 64 kbps in banda HF
Università degli Studi di Roma "La Sapienza"
Stefano Rinauro
Codifica di Reed-Solomon
per un modem digitale a 64 kbps
in banda HF
Tesi svolta per il conseguimento
della laurea di primo livello in
Ingegneria delle Telecomunicazioni
Relatore:
Chiar.mo Prof. Roberto Cusani
Sessione di Laurea:
Dicembre 2003
Indice
1
Introduzione.......................................................................................................... 2
2
I codici di Reed Solomon ..................................................................................... 3
2.1
Generalità.......................................................................................................... 3
2.2
I campi di Galois .............................................................................................. 5
2.3
Codifica ............................................................................................................ 7
2.4
Decodifica......................................................................................................... 9
3 Dimensionamento del codice RS per un modem HF a 64 kbps ......................... 17
3.1
Il modem HF a 64 kbps e la relativa codifica RS........................................... 17
3.2
Realizzazione SW della procedura di co-decodifica RS ................................ 21
3.3
Risultati e dimensionamento del codice RS ................................................... 24
4 Conclusioni......................................................................................................... 30
5
Bibliografia......................................................................................................... 30
1 Introduzione
Lo scopo del presente studio è il dimensionamento di un codice di Reed Solomon,
inserito nella strategia di codifica per la protezione dei dati nell’ambito del progetto di
un modem a 64 kbps in corso presso il Dip. Infocom.
Il codice RS opera come stadio di codifica esterna nell’ambito di una codifica
concatenata, nella quale si ha come codice interno un convoluzionale.
La mansione principale della codifica esterna consiste nell’attivare un opportuno
protocollo ARQ nel caso in cui la trama ricevuta risulti corrotta dagli errori introdotti
dal canale di trasmissione. A tal fine svolge un ruolo determinante la rivelazione degli
errori, più che la loro correzione. Il dimensionamento è dunque orientato
fondamentalmente a minimizzare il numero di trame errate non rilevate, non tanto a
massimizzare quelle corrette, mediante l’introduzione di una ridondanza più contenuta
rispetto ad un codice di tipo FEC.
La scelta di un Reed Solomon come codice esterno è dettata dal fatto che tali codici
ben si adattano a trattare configurazioni di errori a raffica (ovvero a burst), quali quelle
tipicamente introdotte dal decoder convoluzionale (algoritmo di Viterbi).
Nel presente documento sono in primo luogo esposti i principi e gli algoritmi di
codifica/decodifica più comuni relativi a questa classe di codici. Successivamente sono
riportati i risultati e le considerazioni relative al dimensionamento del codice nel caso in
esame.
Lo studio sul dimensionamento è stato effettuato via software. Il programma
utilizzato genera delle trame e le codifica. Gli errori sono poi aggiunti leggendo le loro
posizioni dai risultati di un cospicuo numero di simulazioni (24 canali, ovvero 24
supertrame da 72 blocchi di 6 kbit ciascuno) svolte sul codice interno. Segue poi la fase
di decodifica e sono riportati i risultati in termini del numero di trame corrette, trame
errate rilevate, e trame errate non rilevate.
Codifica di Reed-Solomon per un modem HF a 64 kbps
2 I codici di Reed Solomon
2.1 Generalità
I codici di Reed Solomon sono codici ciclici non binari, orientati cioè ad un alfabeto
di q simboli. Tipicamente si sceglie una cardinalità potenza di due e si considerano i
simboli come composti da sequenze di m bit, con m intero positivo maggiore di 1 in
modo da applicare tale codifica a flussi di dati binari.
Data la dimensione dei simboli si ha che esiste un codice di Reed Solomon RS (n, k)
per ogni n e k tali che:
0 < k < n < 2m +2
dove k è il numero di simboli di informazione da proteggere e n è il numero di simboli
totali che compongono la parola di codice. Nonostante il limite superiore imposto ad n
sia dato da 2m+2 la struttura maggiormente usata per i Reed Solomon prevede una
lunghezza di codeword pari a 2m –1.
La capacità di correzione t dipende invece dal rapporto di codifica ed è pari a
n−k
.
2
Stante tale rapporto tra il numero dei simboli di ridondanza e la capacità di correzione i
Reed Solomon appartengono alla classe dei codici MDS (Maximum Distance
Separable), ovvero conseguono la massima distanza minima ottenibile rispetto ad altri
codici lineari a blocchi a parità di n e k.
La capacità di correzione delle cancellazioni è data da (n-k). Per quanto riguarda
invece la correzione simultanea di errori e cancellazioni la capacità del codice può
esprimersi come:
2err + canc < n-k
L’errore sul simbolo si verifica quando anche uno solo dei bit che lo compongono
risulta errato. Ciò comporta che un codice di Reed Solomon può correggere, nel
peggiore dei casi, fino a t bit errati (se ognuno dei t simboli presenta un solo bit errato),
e nel migliore dei casi fino a tm (se gli t simboli sono completamente errati). Per questo
motivo i codici di Reed Solomon sono particolarmente adatti a correggere errori a
raffica ovvero a burst.
Gli algoritmi di decodifica permettono di correggere errori (fino ad un massimo di t)
e cancellazioni (fino ad un massimo di 2t). All’atto della decodifica si hanno tre casi
possibili: se il numero di errori e cancellazioni non eccede 2t la codeword verrà corretta,
altrimenti il decoder rileverà la presenza di errori oppure commetterà un errore in
decodifica nel caso in cui il pattern di errori abbia trasformato una codeword trasmessa
in un’altra codeword valida. Le probabilità di questi eventi dipendono dal rate del
codice in relazione alla distribuzione degli errori. (Vedi[2.])
4
2.2
I campi di Galois
Per comprendere i principi alla base delle operazioni di codifica e decodifica è
necessario conoscere la teoria dei campi a elementi finiti – detti anche campi di Galois sulla quale si basano i codici ciclici, e quindi anche i Reed Solomon.
Per ogni numero primo q, esiste un campo di Galois GF(q) composto da q elementi.
Tale campo può essere esteso nel campo GF(qm) con m intero maggiore di 1. Per i
codici di Reed Solomon ci si riferisce tipicamente al campo GF(2m), estensione del
campo GF(2).
Un campo di Galois è in effetti un insieme finito di elementi sul quale sono definite
le operazioni di somma e prodotto e che gode delle seguenti proprietà:
a) chiusura rispetto alle suddette operazioni
b) associatività, commutatività, distributività
c) esistenza dell’elemento neutro rispetto alla somma (0) e rispetto al prodotto (1)
d) esistenza, per ogni elemento u, del corrispettivo elemento –u (al fine di definire
l’operazione di differenza) e, per u ≠ 0, dell’elemento u-1 (al fine di definire la
divisione).
Oltre agli elementi 0 e 1, presenti per definizione, nel campo GF(2m), esiste
sicuramente un ulteriore elemento α - detto elemento primitivo - tale che ogni elemento
non nullo del campo può rappresentarsi come potenza di α.
In tal modo, a partire dalla terna di numeri 0, 1, α, è possibile costruire un insieme
infinito di elementi. Per ottenere un insieme finito di cardinalità 2m, che oltretutto goda
delle proprietà viste è necessario imporre un’ulteriore condizione. Tale condizione è
data dalla seguente espressione:
α (2
m
−1)
=1=α0
5
In tal modo ogni elemento dell’insieme che risulti da una potenza di α maggiore di
2m – 1 può ridursi ad un altro elemento che risulti da una potenza di α minore, ad
esempio:
α (2
m
+n)
= α (2
m
−1)
⋅ α ( n +1) = α ( n +1)
La condizione espressa riflette peraltro una proprietà dell’elemento primitivo.
Definito infatti ordine di un elemento β, il più piccolo esponente e per il quale, β e = 1 ,
si ha che l’elemento primitivo ha ordine 2 m − 1 ovvero il maggiore possibile.
L’elemento primitivo α è una delle radici del cosiddetto polinomio primitivo p(x)
che è in effetti la funzione che definisce un campo di Galois. Un polinomio di grado m è
primitivo se è irriducibile e se il più piccolo intero n per cui risulta divisore di x n + 1 è
2 m − 1 .(vedi[2.])
Il legame tra la teoria dei campi ad elementi finiti ed i codici di Reed Solomon sta
nel fatto che si pongono in corrispondenza biunivoca i q simboli da m bit dell’alfabeto
del codice, con gli elementi di un campo GF(2m). D’ora in poi quindi ci si riferirà
indifferentemente agli elementi del campo o ai simboli del codice.
Esistono due modalità di rappresentazione degli elementi del campo di Galois.
La prima – detta index form – è una rappresentazione in termini dell’esponente di α, del
tutto simile alla rappresentazione in decibel. In questo senso si avrà che:
β (index form ) = log α β
Per 0 si considera 0 = α −1 .
Si possono anche rappresentare gli elementi per mezzo di m-ple binarie (polynomial
form) del tipo (00…0) per 0, (00…1) per 1, (100…0) per α m−1 . Per gli elementi
successivi l’m-pla corrispondente si ottiene dalla divisione in modulo per il polinomio
primitivo, considerando i coefficienti del resto in termini di α 0 Lα m −1 .
6
Le operazione aritmetiche su GF(2m) sono leggermente differenti da quelle
ordinarie. L’addizione viene svolta mediante l’operatore logico or esclusivo ovvero xor
tra le due m-ple rappresentanti gli addendi.
La sottrazione, a causa della natura dello xor, risulta analoga.
Per il prodotto risulta invece più conveniente la index form, dove il risultato è dato
dalla somma degli elementi, nella rappresentazione logaritmica. Se si volesse realizzare
il prodotto in forma polinomiale sarebbe necessaria la costruzione di una opportuna
look-up table.
Tali procedure permettono di ricavare delle tavole che diano una descrizione
esaustiva del risultato della somma e del prodotto di ciascun elemento per ogni altro
elemento del campo.
Tale risultato è importante in quanto gli algoritmi di codifica e decodifica si basano
su operazioni algebriche compiute sui simboli delle parole – visti come elementi di un
opportuno campo di Galois.
2.3
Codifica
Come detto la forma più usata dei codici di Reed Solomon risulta essere la
RS ( 2 m − 1 , 2 m − 1 − 2t ) , dove 2t rappresenta il numero di simboli di ridondanza e t
indica la capacità di correzione del codice.
Il polinomio generatore per un RS è definito come:
g ( x) = ( x − α j 0 ) ⋅ ( x − α j 0+1 ) ⋅ ( x − α j 0+ 2 ) ⋅ K ⋅ ( x − α j 0+ 2t −1 ) = g 0 + g1 x + g 2 x 2 + L + g 2t x 2t
in cui j0 ∈ [0, 1].
Il grado del polinomio generatore è uguale al numero di simboli di parità, come
avviene per i codici di Bose, Chaudhuri, Hocquenghem, dei quali i Reed Solomon sono
una sottoclasse.
Poniamo che il messaggio da codificare – la dataword – sia (d1 , d 2 , L , d k ) in cui
ognuno dei di è un numero composto da m bit, e può essere rappresentato da un
7
elemento del campo GF (2m). Possiamo pensare a questi simboli come ad i coefficienti
di un polinomio come nella seguente forma:
d ( x) = d 0 + d1 x + d 2 x 2 + L + d k −1 x k −1
L’algoritmo di codifica consiste fondamentalmente nell’ottenere una codeword –
rappresentata da un polinomio di grado n - 1 che sia divisibile per g(x). Un modo molto
semplice ed intuitivo per ottenere ciò sarebbe quello di ricavare la parola di codice dal
prodotto tra la dataword e il polinomio generatore:
c( x ) = d ( x ) g ( x )
Purtroppo questa semplice implementazione porta ad un codice non sistematico.
Per ottenere una codifica sistematica si considera come codeword:
c( x ) = x 2t d ( x) + p ( x )
con
p ( x) = x 2t d ( x) mod g ( x)
In questo modo effettivamente il polinomio c(x) presenta come coefficienti dei
termini di grado 0….2t i simboli di parità, e come coefficienti dei termini di grado
successivo i simboli di informazione.
Abbiamo così ottenuto una codeword esattamente divisibile per il polinomio
generatore. Qualora il rumore introdotto dal canale vada a modificare i simboli della
codeword, il decoder potrà valutare semplicemente la sua validità andando ad eseguire
la divisione per g(x). L’eventuale presenza di un resto non nullo indica la presenza di un
errore.
8
2.4
Decodifica
Poniamo che durante la trasmissione la parola codificata sia stata affetta da errori
introdotti dal canale. Possiamo pensare di rappresentare il pattern di errori anche esso
sotto forma polinomiale nella maniera seguente.
e( x ) = r ( x ) − c ( x )
con r(x) parola ricevuta.
Più in generale e(x) avrà una strutture del tipo:
e( x) = e0 + e1 x + e2 x 2 + L + en −1 x n−1
In cui gli ei appartengono a GF (2m) e indicano il valore dell’errore, mentre il grado
del termine indica la posizione in cui si è verificato l’errore.
E’ importante sottolineare una differenza con i codici binari; in quel caso infatti
l’unica incognita del problema della correzione degli errori era la locazione dell’errore
stesso in quanto nota questa il bit era automaticamente corretto mediante una negazione.
Nel caso non binario invece, al fine di correggere l’errore è necessario conoscere non
solo la posizione del simbolo errato, ma anche il suo valore originario. In questo senso
abbiamo il doppio delle incognite nel problema, e quindi abbiamo bisogno del doppio
delle relazioni per giungere ad una soluzione.
Il primo passo della procedura di decodifica, così come per la maggior parte dei
codici a blocchi, è dato dal calcolo della sindrome associata alla parola ricevuta. Questo
passaggio permette di rilevare la presenza di errori in quanto le sole codeword valide
godono della proprietà di avere sindrome nulla. La presenza di una sindrome diversa da
zero denota la presenza di almeno un errore nella parola ricevuta.
La sindrome S sarà composta di n-k simboli S = {Si} i = 1,2,….,n-k
9
La struttura del codice facilita molto il calcolo degli elementi della sindrome. Come
detto infatti ogni codeword valida sarà per definizione proporzionale al polinomio
generatore. In questo senso, essendo α, α2, … ,α2t radici di g(x) dovranno esserlo anche
del polinomio rappresentante una qualunque parola di codice valida. I simboli della
sindrome S associata alla parola r(x) potranno dunque calcolarsi come:
S i = r (α i )
i = 1,2,….,2t
E’ utile ricordare che, essendo:
r ( x ) = c ( x) + e( x )
e che:
c(α i ) = 0
i = 1, 2, … , 2t
di fatto la sindrome è data dal polinomio e(x) rappresentante il pattern di errori
calcolato sulle radici del polinomio generatore.
Poniamo di avere ricevuto una r(x) con ν errori nelle posizioni x j1 , x j 2 , K , x jν ,
cosicché:
e ( x ) = e j 1 x j 1 + e j 2 x j 2 + L + e jν x j ν
dove l’indice i = 1,2,…,ν si riferisce al primo, secondo, … , ν-mo errore, mentre j si
riferisce alla posizione dell’errore. A questo punto è possibile riscrivere l’espressione
per il calcolo dei simboli della sindrome come:
si = r (α i ) = e(α i ) = e j1 β1i + e j 2 β 2i + L + e jν βνi
i = 1,2,….,2t
avendo posto α j1 = β1 .
10
Dal momento che non sono note le posizioni degli errori questa forma non può
essere usata per calcolare la sindrome che sarà invece calcolata a partire da r(x) e gli Si
così ottenuti verranno utilizzati come termini noti nel sistema sopradescritto che
presenta, come anticipato, 2t relazioni. Risulta a questo punto chiara la limitazione alla
correzione di soli t errori, in quanto il sistema risulta compatibile solo se ν non eccede t,
caso in cui il sistema presenta appunto 2t incognite.
Purtroppo il sistema risulta non lineare e non è quindi risolubile con le tecniche
usate per i sistemi lineari.
Per ricavare le posizioni degli errori occorsi si introduce il cosiddetto error locator
polynomial, le cui radici indicano le posizioni degli errori nel pattern e(x):
σ ( x ) = x t + σ 1 x t −1 + ... + σ t
Il problema sta nel ricavare i valori dei coefficienti σi a partire dal valore degli elementi
della sindrome.
Calcolando il polinomio σ (x) in una posizione di errore Xk, in modo che si annulli,e
moltiplicandolo per X jk si ha (vedi[1.]):
X kjσ ( X k ) = X kt + j + σ 1 X kt + j −1 + ...σ t X kj = 0
Sommando questa espressione per k = 1, 2, …, t e considerando che (vedi[3.]):
( ) ( )
t
S i = r (α ) = c α + e α = ∑ ek X ki
i
i
i
k =1
si ha:
S t + j + σ 1 S t + j −1 + ... + σ t S j = 0
j = 1, 2, …, t
11
Tale sistema di equazioni, dette identità di Newton, ha come soluzione i coefficienti
dell’error locator polynomial. Per codici di piccole dimensioni tale sistema può
risolversi mediante il metodo di Cramer, ma per codici più complessi tale metodo risulta
inefficiente ed è necessario affrontare il problema in altro modo. Tale difficoltà venne
superata nel 1967, quando E. R. Berlekamp propose un algoritmo efficiente per il
calcolo dei coefficienti σi; l’anno seguente inoltre J. L. Massey dimostrò che il problema
è equivalente a quello di sintetizzare il più breve registro a scorrimento a retroazione
lineare capace di generare una data sequenza, e che questo è equivalente all’algoritmo di
Berlekamp. Un tale approccio viene correntemente utilizzato per la decodifica di tali
codici, ed è indicato come algoritmo di Berlekamp-Massey.
Il Circuito mostrato in Figura 1 implementa infatti le equazioni:
S j = −C1 S j −1 − C 2 S j − 2 − ... − C t S j −t
j = t+1, t+2,…
ovvero le identità di Newton, avendo posto σi = Ci.
+
+
x
x
-C1
Sj-1
+
Sj-2
+
x
-C2
Sj-3
x
-C3
x
-Ct-1
Sj-t
-Ct
Sj-t-1, Sj-t-2, ....…
Figura 1 Circuito LFSR
12
Detto connection polynomial il polinomio definito come:
t
C (x ) = 1 + ∑ Ci x i
i =1
si ha che il calcolo dei coefficienti dell’error location polynomial equivale a
determinare il polinomio C(x) per un LFSR che generi la sequenza St+1, St+2… con stati
iniziali S1, …St.
Data una determinata sequenza di valori della sindrome vi è un determinato numero di
polinomi C(x) di grado diverso che li può generare. Ciò è consistente con il fatto che
diversi pattern di errori possono dar luogo alla medesima sindrome. La decodifica a
massima verosimiglianza impone di scegliere tra i vari possibili, il pattern con il numero
minimo di errori, che equivale al polinomio di grado minore (cosa che si riflette in una
minore lunghezza del registro).
L’algoritmo di Berlekamp Massey sintetizza il registro a scorrimento a retroazione
lineare di lunghezza minima mediante una routine iterativa che inizia considerando il
più piccolo registro possibile e facendogli generare la sindrome. Gli elementi così
ricavati sono via via confrontati con quelli effettivi. Ogniqualvolta si ha una discrepanza
il registro considerato viene modificato e il procedimento ricomincia fino a quando non
si ottiene tutta la sindrome.
I passi dell’algoritmo sono i seguenti:
a) Inizializza le variabili:
C(x) = 1 (connection polynomial)
D(x) = x (termine di correzione)
L = 0 (lunghezza del registro)
n = 1 (contatore degli elementi della sindrome)
b) Considera il l’elemento successivo della sindrome e calcola la discrepanza:
L
δ = S n + ∑ C i S n −i
i =1
13
c) Testa il valore della discrepanza:
se δ = 0 vai al passo h)
altrimenti vai al passo d)
d) Modifica il polinomio C(x):
C*(x) = C(x) - δD(x)
e) Testa la lunghezza del registro:
se 2L ≥ n vai al passo g)
altrimenti vai al passo f)
f) Cambia la lunghezza del registro e modifica il termine di correzione:
L=n-L
D*(x) = C(x)/ δ
g) Aggiorna il polinomio C(x):
C(x) = C*(x)
h) Aggiorna il termine di correzione:
D(x) = xD*(x)
i) Aggiorna il contatore degli elementi della sindrome :
n = n+1
14
j) Verifica il numero di elementi della sindrome:
se n < d ricomincia da b)
altrimenti esci.
Il polinomio C(x) così ottenuto è quello del registro di interesse.
Il connection polynomial è in un primo momento posto uguale ad 1 ed è
successivamente modificato in modo da generare correttamente gli elementi della
sindrome in sequenza. D(x) è il termine usato per modificare il polinomio ogni volta che
si riscontri una discrepanza diversa da zero. Ad ogni iterazione tale discrepanza è la
differenza tra il valore dell’elemento della sindrome e quello calcolato dal registro
ottenuto in quella iterazione. E’ da notarsi come alla prima iterazione la discrepanza sia
data da S1 anche se non ci sono elementi precedenti da cui tale valore può essere stato
calcolato.
Ogni volta che la discrepanza è non nulla C(x) è modificato in funzione della
discrepanza stessa e del termine correttivo. Tale modifica è la parte più interessante
dell’intero algoritmo in quanto permette di ottenere un polinomio che annulli la
discrepanza non solo al passo corrente, ma anche nei precedenti. In altre parole la
modifica non è influente per quanto riguarda la generazione degli elementi della
sindrome precedenti. Questo fatto rende molto efficiente l’algoritmo limitando
notevolmente il numero di passi da svolgere.
Evidentemente, essendo t la capacità correttiva del codice, qualora la lunghezza
finale L del registro (che coincide con il grado di C(x) e quindi con il numero di errori)
ecceda tale valore, non è assicurata un’esatta correzione della codeword. (Vedi [1.])
L’algoritmo di Berlekamp Massey è quello implementato dal software con cui si sono
svolte le simulazioni per dimensionare il codice in esame.
Una volta che siano noti tali coefficienti è facile calcolare le radici dell’error locator
polynomial ottenendo così le posizioni degli errori. Un algoritmo usato a questo fine è la
Chien Search, che è in realtà un metodo di ricerca esaustivo. Le radici infatti saranno
uno o più elementi del campo di Galois e l’algoritmo prevede semplicemente di
15
calcolare il polinomio in tutti gli elementi del campo GF(2m). Ogni volta che il
polinomio si annulla la radice appena trovata indica la posizione di un errore.
E’
importante
notare
l’arbitrarietà
nell’associazione
della
posizione
all’indicizzazione che nel polinomio e(x) indica il numero dell’errore.
Una volta note le posizioni degli errori si possono ricavare i valore degli errori
risolvendo il sistema di 2t equazioni dato dalle relazioni tra gli elementi della sindrome
e il polinomio e(x) calcolato nelle radici di g(x).
Un metodo più efficiente per l’individuazione del valore degli errori è dato
dall’algoritmo di Forney che definisce un polinomio specifico che mette in relazione la
posizione degli errori e il loro valore. Mediante tale relazione si possono ricavare i
valori, essendo note le posizioni.(Vedi [4.])
Come emerge in molti passi del processo di decodifica, qualora si abbia a che fare
con un polinomio e(x) di grado ν > t – ovvero con pattern da più di t errori – il codice
non è in grado di effettuare la correzione, infatti i sistemi introdotti non risultano
compatibili.
Noti anche i valori ej1,…, ejν è possibile ricostruire il polinomio e’(x) che si suppone
sia occorso e, conseguentemente, correggere la parola ricevuta e considerata errata in
seguito al calcolo della sindrome:
c′( x ) = r ( x ) + e′( x ) = c( x ) + e(x ) + e′(x )
L’operazione di decodifica è verificata se il calcolo della sindrome dà risultato
positivo (S = 0). In caso contrario si può comunque asserire la rivelazione dell’errore
avvenuto.
Come nella maggior parte dei codici a blocchi, la mancata rivelazione di un errore è
dovuta al fatto che il pattern di errore ha trasformato r(x) in una nuova parola di codice
valida e quindi, per definizione, caratterizzata da sindrome nulla.
16
3 Dimensionamento del codice RS per un
modem HF a 64 kbps
3.1 Il modem HF a 64 kbps e la relativa codifica RS
Lo studio e la realizzazione del codice RS descritto nel presente documento si
inserisce all’interno di un progetto di ricerca attualmente in corso di svolgimento presso
il Dipartimento Infocom in collaborazione con la Marconi-Selenia, Pomezia (Roma).
Il progetto prevede, nell’arco di tre anni di lavoro, la definizione, la progettazione e
la realizzazione prototipale di un modem digitale operante in banda HF con velocità di
trasmissione sino a 64 kbps in aria. Dopo una fase di studio preliminare sulle
caratteristiche del canale HF e sulle soluzioni tecniche attualmente considerate a livello
mondiale per la trasmissione dati ad alta velocità in HF, il progetto si è orientato per una
soluzione single-tone (e non multi-carrier) con modulazione 16-QAM ed occupazione
di banda intorno ai 25 kHz. Tale scelta è giustificata dalla disponibilità di un
equalizzatore particolarmente potente, detto MAP ridotto (RMAP), mentre per il
codificatore al momento è stato scelto un classico codice convoluzionale, con
interleaving.
In tale ambito rimaneva da definire la codifica a blocchi, oggetto del presente
lavoro.
A tale proposito si è fatto riferimento alla classica soluzione della codifica
concatenata, che prevede due livelli di codifica (Figura 2). Un primo codice detto codice
esterno (outer code), tipicamente un Reed Solomon, introduce un primo livello di
ridondanza; dopodiché le parole di codice così generate costituiscono l’ingresso di un
successivo codificatore – codice interno (inner code) – tipicamente binario.
Il grado di ridondanza introdotto è molto elevato (il rapporto di codifica
complessivo è dato dal prodotto dei rate dei due codici interno ed esterno), ma a
dispetto di ciò i passi di codifica/decodifica sono semplificati in quanto sono eseguiti in
due passi rispetto ad un codice a blocchi che presenti lo stesso rapporto di codifica
totale.
17
Data
in
Outer
Coder
Data
out
Inner
Coder
Interleaver
Channel
Deinterleaver
Inner
Decoder
Outer
Decoder
Figura 2 Codice concatenato
Nel progetto in esame la codifica interna è data da un codice convoluzionale con
rate Ri = 3 4 . La finalità di questo passo di codifica è la correzione del maggior numero
possibile di errori introdotti dal canale. Per il codice esterno si è invece scelto un Reed
Solomon. Questa parte di codifica ha invece ha lo scopo di rilevare i blocchi errati al
fine di permettere la ritrasmissione di una trama eventualmente corrotta mediante un
protocollo ARQ. ARQ (Automatic Repeat reQuest) è una tecnica che prevede la
suddivisione dei dati in pacchetti in ognuno dei quali sono presenti dei bit di controllo di
parità mediante i quali è possibile desumere in ricezione se il pacchetto sia o meno
corrotto da errori. Qualora ciò si verifichi il trasmittente provvederà a rinviare il
pacchetto con modalità definite da opportuni protocolli (Stop & Wait, Go back n…).
Stante tale finalità del codice il suo dimensionamento è stato orientato ad introdurre
una ridondanza più limitata rispetto al caso di un codice a correzione. La scelta della
dimensione della parola di dati e della parola di codice ha come fine il minimizzare (e
possibilmente rendere nullo) il numero di trame errate consegnate al ricevitore. In
questa analisi va tuttavia tenuto presente l’impatto sul throughput dell’intero sistema. È
infatti auspicabile – a parità di errori rilevati – ridurre al minimo il numero di
ritrasmissioni necessarie al fine di non rendere troppo frammentato e incostante il flusso
di dati consegnato al ricevitore.
Il sistema di trasmissione prevede l’invio di trame strutturate come segue (Figura 3)
Ad un preambolo di 281 simboli segue un’alternanza di blocchi informativi ( 2048
simboli) e di simboli noti di training – in numero di 120. Tale alternanza si ripete per un
numero di 72 blocchi informativi, dopodiché la struttura si ripete con tale ciclicità.
18
La scelta della lunghezza del blocco informativo, anche detto frame, è influenzata da
considerazioni trasmissive. Data la modellizzazione del canale (Rayleigh Fading
Channel) è infatti necessaria una trasmissione continuativa per un determinato periodo
di tempo al fine di permettere al ricevitore di stimare la variabilità del canale. Stante la
modulazione adottata a 2048 simboli corrispondono 8Kbit. Considerando anche la
ridondanza introdotta dal codice interno è necessario che il codificatore convoluzionale
abbia come input dei blocchi da 6Kbit.
Data la struttura del codice concatenato questi blocchi da 6 kbit dovranno essere dati
dalle parole di codice del Reed Solomon.
Trama
RP
RP
M
Blocco Dati
Blocco Dati #1
M
M
Blocco Dati #72
281 simboli di preambolo 8PSK
120 simboli noti 8PSK
2048 simboli informativi 16QAM
Figura 3 Struttura della trama a livello fisico (forma d’onda trasmessa)
Sulla base di tali dati iniziali è stata presa la prima scelta riguardante il
dimensionamento del codice, ovvero quella relativa alla dimensione m in bit dei simboli
dell’alfabeto di codice stabilita nella misura di 8 bit (1 byte). Tale decisione ha più
motivazioni. Innanzitutto il byte risulta un comodo e consueto livello di granularità in
molte applicazioni. Per di più tale scelta porta a parole di codice di 2 8−1 = 255 simboli
(la forma più usata dei codici di Reed Solomon prevede codeword di lunghezza 2 m−1 ).
Questo vincolo risulta essere comodo per due motivi. Infatti non solo i codici RS (255 ,
255 – 2t) sono le implementazioni più usate dei Reed Solomon, ma oltretutto nel nostro
caso, dal momento che 255 byte corrispondono a 2Kbit circa, questa dimensione di
19
codeword permette un elegante partizionamento del blocco di 6Kbit in tre parole di
codice.
Possiamo dunque pensare l’ambiente di lavoro strutturato in buona approssimazione
nel modo seguente (Figura 4).
Il flusso di dati generato dalla sorgente viene consegnato segmentato in blocchi da k*m
bit al codificatore esterno (Reed Solomon) che applica un primo livello di ridondanza
aggiungendo ai bit di informazione un campo CRC di 2t*m bit tale che (k+2t)m=2 Kbit.
Lo scopo del lavoro presentato è un opportuno dimensionamento di questo campo
CRC.
B locch i di tra sporto
C od ifica E stern a
Accorp am en to
d ei b locch i
C odifica In tern a R = 3 /4
In terleavin g
Ad attam en to alla
S tru ttu ra di tram a
#1
#3
m * k b it
m * k b it
#1
CRC
#3
CRC
2 K bit
2 K bit
6 k bit
8 k bit
8 k bit
train
16 Q AM
Figura 4 Ambiente di Lavoro
Successivamente tali blocchi vengono inviati sequenzialmente in input al codificatore
interno (convoluzionale). Lo streaming in uscita, opportunamente ridondato dal codice,
viene posto in ingresso all’interleaver. L’interleaving si rende necessario in situazioni in
cui il canale introduce configurazioni di errori a burst, e consiste nel riarrangiare
l’ordine dei bit prima della trasmissione e nel compiere l’operazione inversa in
ricezione. In questo modo si cerca di rendere il più casuale possibile il pattern di errori
20
che affligge la sequenza di bit consegnata al decodificatore. Si adotta lo schema di
interleaving riga/colonna di grado 2. Infine il flusso di bit verrà risegmentato in blocchi
da 8 kbit, ovvero da 2048 simboli. Tali simboli verranno quindi calati nella trama sopra
descritta (operazione che comporterà un opportuno compattamento temporale al fine di
inserire i simboli noti) e trasmessi nel canale.
In ricezione le medesime operazioni compiute sono le stesse in ordine inverso.
3.2 Realizzazione SW della procedura di co-decodifica RS
La scelta del tasso di ridondanza del codice è stata svolta mediante una realizzazione
software della procedura di co-decodifica RS.
Un software realizzato in un altro ambito effettua una simulazione del collegamento
comprendente il codice interno (SCCI). Sfruttando tale soluzione già pronta si è pensato
in un primo momento di strutturare il software per la codifica RS aggiungendo al codice
già scritto i blocchi funzionali RS (operazione di codifica) e RS-1 (operazione di
decodifica) così come mostrato nel seguente schema (Figura 5)
Sorgente
Destinazione
RS
SCCI
RS-1
Figura 5 Schema a blocchi della realizzazione software comprendente il SCCI
E’ però opportuno notare che, ai fini del dimensionamento del codice RS nella
realizzazione software usata, la simulazione dell’ambiente di trasmissione è
inessenziale. Se infatti si potesse sostituire l’intero blocco SCCI con un semplice blocco
che, in corrispondenza degli errori commessi dal decoder convoluzionale, andasse a
21
negare il bit corrispondente nel blocco codificato, il risultato sarebbe invariato, avendo
però guadagnato in tempo di elaborazione. Questa soluzione è stata infatti applicata
sfruttando dei file di testo in cui il programma SCCI scrive, per ogni blocco da 6 Kbit, il
numero e la posizione degli eventuali bit errati dopo la decodifica convoluzionale. Alla
luce di ciò il programma per la realizzazione è stato semplificato alla seguente struttura
(Figura 6)
SCCI
Disp.
Errori
Sorgente
RS
Destinazione
RS-1
Figura 6 Schema a blocchi della realizzazione software non comprendente il SCCI
Il funzionamento di tale programma è strutturato come segue.
•
Il prima istanza vengono generate tre parole binarie pseudocasuali da k*m bit, dove
k è parametrizzato ed m = 8 .
•
Queste vengono successivamente trasformate in parole di k simboli convertendo
ogni m-pla di bit in un numero in forma decimale.
•
Le parole così ottenute sono quindi codificate.
Le procedure di codifica e decodifica di Reed Solomon sono state prese dal “Reed
Solomon coding/decoding package v1.0” by Phil Karn (Sept 1996). Tale pacchetto
implementa le funzioni di codifica e decodifica avendo come gradi di libertà la
dimensione in bit dei simboli m, e la capacità di correzione t del codice. Sono anche
comprese delle funzioni che inizializzano delle tavole di conversione per le varie
rappresentazioni degli elementi dei campi ad elementi finiti e che generano, a partire da
i valori di m e t, il polinomio generatore del codice.
22
•
Una volta effettuata la codifica, le parole di codice così ottenute (di n simboli
ciascuna, ovvero di m*n bit = 2 Kbit) sono nuovamente trasformate in forma binaria
e riunificate in un unico blocco da 6 Kbit.
•
Su tale blocco sono aggiunti gli errori (il pattern di errori per ogni blocco è letto da
un file di testo che contiene i risultati delle simulazioni del codice interno su 24
supertrame (canali) da 72 blocchi da 6 Kbit ciascuno). Naturalmente la maggior
parte dei blocchi non sarà affetta da errori e quindi non modificata da questo
passaggio.
•
Successivamente il blocco affetto da errori viene risegmentato in parole da 2 Kbit
prima e da n simboli poi, mediante una nuova conversione binaria/decimale.
•
Sulle parole così ottenute è applicata la funzione di decodifica.
Per come è strutturato il software che implementa questa funzione si hanno tre
possibili esiti:
a) Il numero di errori è tale da poter essere corretto, nel qual caso la funzione
ritorna il numero di simboli corretti.
b) Il numero di errori eccede la capacità di correzione del codice, e la funzione
ritorna il valore –1, rilevando comunque la codeword come errata.
c) La codeword è riconosciuta come corretta, nel qual caso la funzione ritorna il
valore 0. Come noto questa evenienza è figlia di una effettiva mancanza di
errori, ovvero di un pattern di errori tale da aver trasformato la parola di
codice in un’altra codeword valida.
Per eliminare l’ambiguità legata a quest’ultimo caso, ogni volta che il valore
riportato dalla funzione di decodifica è 0 si esegue un confronto simbolo a simbolo
tra la parola originale e quella decodificata.
Le operazioni precedentemente descritte sono reiterate fino a quando non si arriva alla
fine del file con le configurazioni degli errori. In totale si saranno quindi esaminati:
23
•
24 ∗ 72 = 1728 blocchi da 6 Kbit, corrispondenti a 5184 parole da 2 Kbit che
rappresentano la PDU del protocollo ARQ.
3.3 Risultati e dimensionamento del codice RS
Il dimensionamento del tasso di ridondanza del codice esterno si basa sul numero
atteso di errori commessi in fase di decodifica dal codice interno. Per come è
strutturato, il codice di Reed Solomon opera, come livello di granularità più fine, sul
simbolo e non sulla sequenza di bit che lo compone. In tal senso è importante esaminare
come si distribuiscono nelle parole da 2 Kbit in uscita dal decoder convoluzionale i
simboli errati (che avendo posto m=8 si riducono ai byte errati).
A tale scopo è stato realizzato un software per l’analisi dei risultati della
simulazione del collegamento comprendente il codice interno (SCCI) (Figura 7)
SCCI
Disp.
Errori
Software
per l’analisi
Analisi
Statistica
Figura 7 Schema a blocchi del software per l’analisi della disposizione degli errori
Il programma legge da un file di input i risultati della simulazione SCCI che
riportano, per ogni blocco da 6 Kbit, la posizione dei vari errori. Essendo la ricerca
orientata ai blocchi da 2 Kbit, la posizione dell’errore viene normalizzata rispetto a
questo valore, in modo che, ad esempio, due bit errati nelle posizioni 2048 - 2049 del
primo blocco da 6 Kbit, siano considerati come facenti parte di due blocchi da 2 Kbit
diversi. Inoltre si è orientata la statistica al numero di byte errati in ogni parola in modo
che, anche un burst di 8 bit errati, possa essere considerato (sempre se cade nella giusta
posizione) come un solo simbolo errato.
24
Nel partizionamento implicito dei blocchi da 6 Kbit non si è fatta distinzione tra i
blocchi in prima, seconda e terza posizione. In effetti data la non stazionarietà del canale
trasmissivo
in esame sarebbe stata opportuna una differenziazione in quanto
presumibilmente bit diversi avranno sperimentato una diversa potenza al ricevitore.
Tuttavia in questo caso l’interleaving interviene a rendere inutile un passaggio del
genere in quanto dei bit consegnati al decoder in un’unica parola sono stati trasmessi in
parole diverse.
L’esito dell’analisi statistica sul campione di errori porta alle seguenti
considerazioni:
•
fino alla soglia di x = 21 byte errati l’andamento del numero di codeword affette da
x errori rimane in buona approssimazione decrescente con una certa continuità da un
massimo di 64 codeword con un errore fino a 4 codeword con 21 errori.
•
Dopo tale soglia l’andamento risulta meno regolare e si hanno delle occorrenze (mai
superiori alle dieci codeword) con un numero di errori fino 35.
•
Oltre tale soglia si ha un caso isolato con 41 errori.
Tali risultati sono riportati nel seguente grafico (Figura 8):
totale blocchi esaminati: 5184 - blocchi con zero errori: 4801 (fuori scala)
100
blocchi da 2kbit = 255byte con errori
90
80
70
60
50
40
30
20
10
0
0
1
2
3
4
5
6
7
8
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
numero byte errati in un blocco
Figura 8 Distribuzione degli errori sui byte nei blocchi da 2 kbit
25
Tale distribuzione degli errori porta a considerare la necessità di rilevare almeno
tutti i 35 byte errato che possiamo considerare come massimo, tralasciando il caso
peggiore di per sé poco significativo. Del resto è anche necessaria una considerazione in
termini di efficienza di sistema. In effetti la strategia di codifica ha un doppio impatto
sul throughput di sistema. Infatti si ha una perdita di efficienza dovuta alla ridondanza
introdotta, sia dal FEC che dall’ARQ, alla quale va aggiunta l’ulteriore perdita dovuta
ad eventuali ritrasmissioni. La curva dell’efficienza di fatto si trova al di sotto di un
asintoto fissato dal tasso di ridondanza e raggiunto solo qualora non vi siano
ritrasmissioni (ovvero in una situazione di canale particolarmente favorevole). Il
throughput complessivo del sistema dovuto alla sola introduzione della ridondanza
presenterà evidentemente un andamento decrescente; nella fattispecie si avrà:
Th = 0.75(1 − CRC / 255)
dove con CRC si indica il numero di simboli di ridondanza del codice e dove il fattore
0.75 tiene conto del rate Ri = ¾ del codice interno. Ricordando che CRC può essere
solamente una quantità pari (i codici di Reed Solomon sono del tipo RS (255, 255-2t)
con t capacità di correzione) si ha la seguente situazione (Figura 9):
Throughput complessivo del codice
0,76
0,74
Rate
0,72
0,7
0,68
0,66
0,64
0,62
0
10
20
30
40
50
Simboli di ridondanza (CRC)
Figura 9 Andamento del Throughput complessivo del Codice
26
Come si nota dal grafico un dimensionamento con un campo di ridondanza pari a 36
simboli (35 non è un valore ammesso) comporterebbe un throughput asintotico pari
all’incirca a 0.65.
E’ interessante però esaminare i risultati delle simulazioni svolte. Tali simulazioni –
eseguite con il software descritto precedentemente – sono state effettuate con uno
svariato numero di valori del campo di ridondanza da un minimo di 2 (se non altro per
amore di completezza) ad un massimo di 42. I risultati mostrati di seguito (Figura 10)
riportano per ogni valore di CRC il numero di parole che il codice è stato in grado di
correggere efficacemente (può infatti capitare che un troppo elevato numero di errori
faccia fallire la correzione che pur sempre si basa sul principio di massima
verosimiglianza), il numero di parole errate rilevate ed il numero di parole
eventualmente consegnate errate agli stadi successivi la decodifica
CRC
Codeword Codeword Codeword
corrette
Rilevate
consegnate
errate
2
4
6
8
10
12
14
16
18
20
22
24
26
28
30
32
34
36
38
40
42
67
128
155
170
189
212
229
247
261
274
281
289
305
318
328
331
339
345
350
352
360
3
131
182
198
190
171
154
136
122
109
102
94
78
65
55
52
44
38
33
31
23
313
124
46
15
4
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
Figura 10 Risultati della Realizzazione della co-decodifica RS
27
Risulta di particolare interesse il fatto che, nonostante un palese sottodimensionamento,
già un codice con soli dodici simboli di ridondanza, partendo dall’input delle
simulazioni che può comunque considerarsi un esempio significativo di scenario di
trasmissione, assicuri una trasmissione affidabile. Tale risultato già di per sé
interessante, lo diventa ancora di più se si considera il fatto che per gli esempi con ancor
minore ridondanza che presentano degli errori in decodifica, tali errori sono compiuti un
correzione e quindi non accade mai che i pattern di errori varino una parola di codice in
una diversa parola comunque valida, ma avviene che la decodifica a massima
verosimiglianza fallisce essendo troppo limitata la ridondanza. La spiegazione di tale
fenomeno può essere data dal fatto che il codice di Reed Solomon è non binario. In
questo senso assume rilevanza nella valutazione della distanza minima non solo il
numero minimo di simboli per cui differiscono due parole ma anche il “modulo” della
differenza. Da questo punto di vista è possibile che, nonostante in effetti il numero di
errori superi la distanza minima, la possibile scelta tra i simboli fa sì che non si
verifichino ambiguità tra parole valide.
I risultati della tabella precedente sono riportati nei seguenti grafici (Figura 11 e Figura
12)
Codeword consegnate errate al ricevitore
350
300
Codeword
250
200
150
100
50
0
-50 0
10
20
30
40
50
Simboli di ridondanza
Figura 11 Codeword consegnate errate al ricevitore vs simboli di ridondanza
(campo CRC)
28
Codeword corrette dal codice
400
350
Codeword
300
250
200
150
100
50
0
0
10
20
30
40
50
Codeword rilevate errate (ritrasmissione
richiesta)
250
Codeword
200
150
100
50
0
0
10
20
30
40
50
Figura 12 Codeword corrette e Codeword per cui si richiede la ritrasmissione vs
Simboli di Ridondanza (campo CRC)
29
4 Conclusioni
Le analisi svolte nel presente lavoro mostrano come, a partire da una descrizione
relativamente accurata dell’ambiente in cui si troverà ad operare il codice (rappresentata
dai risultati delle simulazioni svolte sul codice convoluzionale comprendenti anche i
passi di modulazione, equalizzazione ecc…), sia possibile avere una trasmissione
affidabile già con una ridondanza molto limitata (12 simboli di ridondanza).
Occorre però evidenziare come questa soluzione, che presenta il vantaggio di avere
un rate decisamente elevato, sia comunque rischiosa e che è forse troppo affetta dalla
particolarità dei pattern di errori presenti nei dati di input alle simulazioni. Un
dimensionamento più corretto prevede un numero di simboli di ridondanza compreso tra
i 30 e i 36. Tale soluzione, a scapito di un rate decisamente più basso del caso
precedente (oscilla tra lo 0.64 e lo 0.66), presenta una affidabilità in media di valore più
generale con il vantaggio di limitare la percentuale di richieste di ritrasmissione ad un
valore inferiore al 2%.
5 Bibliografia
[1.]
M. Michelson, A. H. Lovesque: “Error – Control Techniques for Digital
Communications”, Wiley Interscience, 1985.
[2.]
B. Sklar: “Reed Solomon Codes”
[3.]
Wen Xu: “Implementation and Performance Evaluation of Reed-Solomon
Codes”, Cornell University, 2001
[4.]
S. LeNgoc, T. Banerjee, Y. Ye: “A PC based General Purpose Reed Solomon
Codec Simulator”
[5.]
M. McGregor, J. Watson: “Implementing the Reed Solomon Code: A Case
Study”
30

Codifica di Reed-Solomon per un modem digitale a 64 kbps in

Transcript

Documenti analoghi

ICT Economia digitale Reti

Un disegno di arte e di vita Scegliere, come ha fatto Max Läubli, di

PICCOLA GUIDA AI SIMBOLI MATEMATICI Simboli di funzione

Durante l`installazione mi viene richiesto un codice PIN

The radiant child: Jean-Michel Basquiat

DIONISO-MU/MT/R Contatto magnetico per porte e finestre radio

I codici di Reed

Richiesta di acquisto

qui