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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
|
<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Trellis-based algorithms for GNU Radio</title><meta name="generator" content="DocBook XSL Stylesheets V1.65.1"><meta name="description" content="This document provides a description of the
Finite State Machine (FSM) implementation and the related
trellis-based encoding and decoding algorithms
for GNU Radio.
"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="article" lang="en"><div class="titlepage"><div><div><h1 class="title"><a name="id2753996"></a>Trellis-based algorithms for GNU Radio</h1></div><div><div class="author"><h3 class="author"><span class="firstname">Achilleas</span> <span class="surname">Anastasopoulos</span></h3><div class="affiliation"><div class="address"><p><br>
<tt class="email"><<a href="mailto:anastas@umich.edu">anastas@umich.edu</a>></tt><br>
</p></div></div></div></div><div><div class="revhistory"><table border="1" width="100%" summary="Revision history"><tr><th align="left" valign="top" colspan="2"><b>Revision History</b></th></tr><tr><td align="left">Revision v0.0</td><td align="left">2006-08-03</td></tr><tr><td align="left" colspan="2">
First cut.
</td></tr></table></div></div><div><div class="abstract"><p class="title"><b>Abstract</b></p><p>This document provides a description of the
Finite State Machine (FSM) implementation and the related
trellis-based encoding and decoding algorithms
for GNU Radio.
</p></div></div></div><div></div><hr></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1"><a href="#intro">Introduction</a></span></dt><dt><span class="sect1"><a href="#fsm">The FSM class</a></span></dt><dt><span class="sect1"><a href="#tcm">TCM: A Complete Example</a></span></dt><dt><span class="sect1"><a href="#future">Future Work</a></span></dt></dl></div><div class="sect1" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="intro"></a>Introduction</h2></div></div><div></div></div><p>....</p><p>
The basic goal of the implementation is to have a generic way of
describing an FSM that is decoupled from whether it describes a
convolutional
code (CC), a trellis code (TC), an inter-symbol interference (ISI)
channel, or any
other communication system that can be modeled with an FSM.
To achieve this goal, we need to separate the pure FSM descrition from the
rest of the model details. For instance, in the case of a rate 2/3 TC,
the FSM should not involve details about the modulation used (it can
be an 8-ary PAM, or 8-PSK, etc). Similarly, when attempting maximum likelihood
sequence detection (MLSD)--using for instance the Viterbi algorithm (VA)--
the VA implementation should not be concerned with the channel details
(such as modulations, channel type, hard or soft inputs, etc).
Clearly, having generality as the primary goal implies some penalty
on the code efficiency, as compared to fully custom implementations.
</p><p>
We will now describe the implementation of the basic ingedient, the FSM.
</p></div><div class="sect1" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="fsm"></a>The FSM class</h2></div></div><div></div></div><p>An FSM describes the evolution of a system with inputs
x<sub>k</sub>, states s<sub>k</sub> and outputs y<sub>k</sub>. At time k the FSM state is s<sub>k</sub>.
Upon reception of a new input symbol x<sub>k</sub>, it outputs an output symbol
y<sub>k</sub> which is a function of both x<sub>k</sub> and s<sub>k</sub>.
It will then move to a next state s<sub>k+1</sub>.
An FSM has a finite number of states, input and output symbols.
All these are formally described as follows:
</p><div class="itemizedlist"><ul type="disc"><li><p>The input alphabet A<sub>I</sub>={0,1,2,...,I-1}, with cardinality I, so that x<sub>k</sub> takes values in A<sub>I</sub>.</p></li><li><p>The state alphabet A<sub>S</sub>={0,1,2,...,S-1}, with cardinality S, so that s<sub>k</sub> takes values in A<sub>S</sub>.</p></li><li><p>The output alphabet A<sub>O</sub>={0,1,2,...,O-1}, with cardinality O, so that y<sub>k</sub> takes values in A<sub>O</sub></p></li><li><p>The "next-state" function NS: A<sub>S</sub> x A<sub>I</sub> --> A<sub>S</sub>,
with the meaning
s<sub>k+1</sub> = NS(s<sub>k</sub>, x<sub>k</sub>)</p></li><li><p>The "output-symbol" function OS: A<sub>S</sub> x A<sub>I</sub> --> A<sub>S</sub>,
with the meaning
y<sub>k</sub> = OS(s<sub>k</sub>, x<sub>k</sub>)</p></li></ul></div><p>
Thus, a complete description of the FSM is given by the
the five-tuple (I,S,O,NS,OS).
Observe that implementation details are hidden
in how the outside world interprets these input and output
integer symbols.
Here is an example of an FSM describing the (2,1) CC
with constraint length 3 and generator polynomial matrix
(1+D+D<sup>2</sup> , 1+D<sup>2</sup>)
from Proakis-Salehi pg. 779.
</p><div class="example"><a name="cc_ex"></a><p class="title"><b>Example 1. (2,1) CC with generator polynomials (1+D+D<sup>2</sup> , 1+D<sup>2</sup>)</b></p><p>
This CC accepts 1 bit at a time, and outputs 2 bits at a time.
It has a shift register storing the last two input bits.
In particular,
b<sub>k</sub>(0)=x<sub>k</sub>+
x<sub>k-1</sub>+x<sub>k-2</sub>, and
b<sub>k</sub>(1)=x<sub>k</sub>+
x<sub>k-2</sub>, where addition is mod-2.
We can represent the state of this system
as s<sub>k</sub> = (x<sub>k-1</sub> x<sub>k-2</sub>)<sub>10</sub>. In addition we can represent its
output symbol as y<sub>k</sub> = (b<sub>k</sub>(1) b<sub>k</sub>(0))<sub>10</sub>.
Based on the above assumptions, the input alphabet A<sub>I</sub>={0,1}, so I=2;
the state alphabet A<sub>S</sub>={0,1,2,3}, so S=4; and
the output alphabet A<sub>O</sub>={0,1,2,3}, so O=4.
The "next-state" function NS(,) is given by
</p><pre class="programlisting">
s<sub>k</sub> x<sub>k</sub> s<sub>k+1</sub>
0 0 0
0 1 2
1 0 0
1 1 2
2 0 1
2 1 3
3 0 1
3 1 3
</pre><p>
The "output-symbol" function OS(,) can be given by
</p><pre class="programlisting">
s<sub>k</sub> x<sub>k</sub> y<sub>k</sub>
0 0 0
0 1 3
1 0 3
1 1 0
2 0 1
2 1 2
3 0 2
3 1 1
</pre><p>
</p><p>
Note that although the CC outputs 2 bits per time period, following
our approach, there is only one (quaternary) output symbol per
time period (for instance, here we use the decimal representation
of the 2-bits). Also note that the modulation used is not part of
the FSM description: it can be BPSK, OOK, BFSK, QPSK with or without Gray mapping, etc;
it is up to the rest of the program to interpret the meaning of
the symbol y<sub>k</sub>.
</p></div><p>
The C++ implementation of the FSM class keeps private information about
I,S,O,NS,OS and public methods to read and write them. The NS
and OS matrices are implemented as STL 1-dimensional vectors.
</p><pre class="programlisting">
class fsm {
private:
int d_I;
int d_S;
int d_O;
std::vector<int> d_NS;
std::vector<int> d_OS;
std::vector<int> d_PS;
std::vector<int> d_PI;
public:
fsm();
fsm(const fsm &FSM);
fsm(const int I, const int S, const int O, const std::vector<int> &NS, const std::vector<int> &OS);
fsm(const char *name);
fsm(const int mod_size, const int ch_length);
int I () const { return d_I; }
int S () const { return d_S; }
int O () const { return d_O; }
const std::vector<int> & NS () const { return d_NS; }
const std::vector<int> & OS () const { return d_OS; }
const std::vector<int> & PS () const { return d_PS; }
const std::vector<int> & PI () const { return d_PI; }
};
</pre><p>
As can be seen, other than the trivial and the copy constructor,
there are three additional
ways to construct an FSM.
</p><div class="itemizedlist"><ul type="disc"><li><p>Supplying the parameters I,S,O,NS,OS:</p><pre class="programlisting">
fsm(const int I, const int S, const int O, const std::vector<int> &NS, const std::vector<int> &OS);
</pre></li><li><p>Giving a filename containing all the FSM information:</p><pre class="programlisting">
fsm(const char *name);
</pre><p>
This information has to be in the following format:
</p><pre class="programlisting">
I S O
NS(0,0) NS(0,1) ... NS(0,I-1)
NS(1,0) NS(1,1) ... NS(1,I-1)
...
NS(S-1,0) NS(S-1,1) ... NS(S-1,I-1)
OS(0,0) OS(0,1) ... OS(0,I-1)
OS(1,0) OS(1,1) ... OS(1,I-1)
...
OS(S-1,0) OS(S-1,1) ... OS(S-1,I-1)
</pre><p>
</p><p>
For instance, the file containing the information for the example mentioned above is of the form:
</p><pre class="programlisting">
2 4 4
0 2
0 2
1 3
1 3
0 3
3 0
1 2
2 1
</pre><p>
</p></li><li><p>The third way is specific to FSMs resulting from shift registers, and the output symbol being the entire transition (ie, current_state and current_input). These FSMs are usefull when describibg ISI channels. In particular the state is comprised of the.....
</p><pre class="programlisting">
fsm(const int mod_size, const int ch_length);
</pre></li></ul></div><p>
Finally, as can be seen from the above description, there are
two more variables included in the FSM class implementation,
the PS and the PI matrices. These are computed internally
when an FSM is instantiated and their meaning is as follows.
Sometimes (eg, in the traceback operation of the VA) we need
to trace the history of the state or the input sequence.
To do this we would like to know for a given state s<sub>k</sub>, what are the possible previous states s<sub>k-1</sub>
and what input symbols x<sub>k-1</sub> will get us from
s<sub>k-1</sub> to s<sub>k</sub>. This information can be derived from NS; however we want to have it ready in a
convenient format.
In the following we assume that for any state,
the number of incoming transitions is the same as the number of
outgoing transitions, ie, equal to I. All applications of interest
have FSMs satisfying this requirement.
If we arbitrarily index the incoming transitions to the current state
by "i", then as i goes from 0 to I-1, PS(s<sub>k</sub>,i)
gives all previous states s<sub>k-1</sub>,
and PI(s<sub>k</sub>,i) gives all previous inputs x<sub>k-1</sub>.
In other words, for any given s<sub>k</sub> and any index i=0,1,...I-1, starting from
s<sub>k-1</sub>=PS(s<sub>k</sub>,i)
with input
x<sub>k-1</sub>=PI(s<sub>k</sub>,i)
will get us to the state s<sub>k</sub>.
More formally, for any i=0,1,...I-1 we have
s<sub>k</sub> = NS(PS(s<sub>k</sub>,i),PI(s<sub>k</sub>,i)).
</p></div><div class="sect1" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="tcm"></a>TCM: A Complete Example</h2></div></div><div></div></div><p>
We now discuss through a concrete example how
the above FSM model can be used in GNU Radio.
The communication system that we want to simulate
consists of a source generating the
input information in packets, a CC encoding each packet separately,
a memoryless modulator,
an additive white Gaussian noise (AWGN) channel, and
the VA performing MLSD.
The program source is as follows.
</p><pre class="programlisting">
1 #!/usr/bin/env python
2
3 from gnuradio import gr
4 from gnuradio import audio
5 from gnuradio import trellis
6 from gnuradio import eng_notation
7 import math
8 import sys
9 import random
10 import fsm_utils
11
12 def run_test (f,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed):
13 fg = gr.flow_graph ()
14
15 # TX
16 src = gr.lfsr_32k_source_s()
17 src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts
18 s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality
19 enc = trellis.encoder_ss(f,0) # initial state = 0
20 mod = gr.chunks_to_symbols_sf(constellation,dimensionality)
21
22 # CHANNEL
23 add = gr.add_ff()
24 noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)
25
26 # RX
27 metrics = trellis.metrics_f(f.O(),dimensionality,constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi
28 va = trellis.viterbi_s(f,K,0,-1) # Put -1 if the Initial/Final states are not set.
29 fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts
30 dst = gr.check_lfsr_32k_s();
31
32 fg.connect (src,src_head,s2fsmi,enc,mod)
33 fg.connect (mod,(add,0))
34 fg.connect (noise,(add,1))
35 fg.connect (add,metrics)
36 fg.connect (metrics,va,fsmi2s,dst)
37
38 fg.run()
39
40 # A bit of cheating: run the program once and print the
41 # final encoder state.
42 # Then put it as the last argument in the viterbi block
43 #print "final state = " , enc.ST()
44
45 ntotal = dst.ntotal ()
46 nright = dst.nright ()
47 runlength = dst.runlength ()
48 return (ntotal,ntotal-nright)
49
50
51 def main(args):
52 nargs = len (args)
53 if nargs == 3:
54 fname=args[0]
55 esn0_db=float(args[1]) # Es/No in dB
56 rep=int(args[2]) # number of times the experiment is run to collect enough errors
57 else:
58 sys.stderr.write ('usage: test_tcm.py fsm_fname Es/No_db repetitions\n')
59 sys.exit (1)
60
61 # system parameters
62 f=trellis.fsm(fname) # get the FSM specification from a file (will hopefully be automated in the future...)
63 Kb=1024*16 # packet size in bits (make it multiple of 16 so it can be packed in a short)
64 bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol
65 K=Kb/bitspersymbol # packet size in trellis steps
66 modulation = fsm_utils.psk4 # see fsm_utlis.py for available predefined modulations
67 dimensionality = modulation[0]
68 constellation = modulation[1]
69 if len(constellation)/dimensionality != f.O():
70 sys.stderr.write ('Incompatible FSM output cardinality and modulation size.\n')
71 sys.exit (1)
72 # calculate average symbol energy
73 Es = 0
74 for i in range(len(constellation)):
75 Es = Es + constellation[i]**2
76 Es = Es / (len(constellation)/dimensionality)
77 N0=Es/pow(10.0,esn0_db/10.0); # noise variance
78
79 tot_s=0
80 terr_s=0
81 for i in range(rep):
82 (s,e)=run_test(f,Kb,bitspersymbol,K,dimensionality,constellation,N0,-long(666+i)) # run experiment with different seed to get different noise realizations
83 tot_s=tot_s+s
84 terr_s=terr_s+e
85 if (i%100==0):
86 print i,s,e,tot_s,terr_s, '%e' % ((1.0*terr_s)/tot_s)
87 # estimate of the (short) error rate
88 print tot_s,terr_s, '%e' % ((1.0*terr_s)/tot_s)
89
90
91 if __name__ == '__main__':
92 main (sys.argv[1:])
</pre><p>
The program is called by
</p><div class="literallayout"><p><br>
./test_tcm.py fsm_fname Es/No_db repetitions<br>
</p></div><p>
where "fsm_fname" is the file containing the FSM specification of the
tested TCM code, "Es/No_db" is the SNR in dB, and "repetitions"
are the number of packets to be transmitted and received in order to
collect sufficient number of errors for an accurate estimate of the
error rate.
</p><p>
The FSM is first intantiated in "main" by
</p><pre class="programlisting">
62 f=trellis.fsm(fname) # get the FSM specification from a file (will hopefully be automated in the future...)
</pre><p>
Each packet has size Kb bits
(we choose Kb to be a multiple of 16 so that all bits fit nicely into shorts and can be generated by the lfsr GNU Radio).
Assuming that the FSM input has cardinality I, each input symbol consists
of bitspersymbol=log<sub>2</sub>( I ). The Kb/16 shorts are now
unpacked to K=Kb/bitspersymbol input
symbols that will drive the FSM encoder.
</p><pre class="programlisting">
63 Kb=1024*16 # packet size in bits (make it multiple of 16 so it can be packed in a short)
64 bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol
65 K=Kb/bitspersymbol # packet size in trellis steps
</pre><p>
The FSM will produce K output symbols (remeber the FSM produces always one output symbol for each input symbol). Each of these symbols needs to be modulated. Since we are simulating the communication system, we need not simulate the actual waveforms. An M-ary, N-dimensional
modulation is completely specified by a set of M, N-dimensional real vectors. In "fsm_utils.py" file we give a number of useful modulations with the following format: modulation = (N,constellation), where
constellation=[c11,c12,...,c1N,c21,c22,...,c2N,...,cM1,cM2,...cMN].
The meaning of the above is that every constellation point c_i
is an N-dimnsional vector c_i=(ci1,ci2,...,ciN)
For instance, 4-ary PAM is represented as
(1,[-3, -1, 1, 3]), while QPSK is represented as
(2,[1, 0, 0, 1, 0, -1, -1, 0]). In our example we choose QPSK modulation.
Clearly, M should be equal to the cardinality of the FSM output, O.
Finally the average symbol energy and noise variance are calculated.
</p><pre class="programlisting">
66 modulation = fsm_utils.psk4 # see fsm_utlis.py for available predefined modulations
67 dimensionality = modulation[0]
68 constellation = modulation[1]
69 if len(constellation)/dimensionality != f.O():
70 sys.stderr.write ('Incompatible FSM output cardinality and modulation size.\n')
71 sys.exit (1)
72 # calculate average symbol energy
73 Es = 0
74 for i in range(len(constellation)):
75 Es = Es + constellation[i]**2
76 Es = Es / (len(constellation)/dimensionality)
77 N0=Es/pow(10.0,esn0_db/10.0); # noise variance
</pre><p>
Then, "run_test" is called with a different "seed" so that we get
different noise realizations.
</p><pre class="programlisting">
82 (s,e)=run_test(f,Kb,bitspersymbol,K,dimensionality,constellation,N0,-long(666+i)) # run experiment with different seed to get different noise realizations
</pre><p>
Let us examine now the "run_test" function.
First we set up the transmitter blocks.
The Kb/16 shorts are first unpacked to
symbols consistent with the FSM input alphabet.
The FSm encoder requires the FSM specification,
and an initial state (which is set to 0 in this example).
</p><pre class="programlisting">
15 # TX
16 src = gr.lfsr_32k_source_s()
17 src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts
18 s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality
19 enc = trellis.encoder_ss(f,0) # initial state = 0
</pre><p>
We now need to modulate the FSM output symbols.
The "chunks_to_symbols_sf" is essentially a memoryless mapper which
for each input symbol y_k
outputs a sequence of N numbers ci1,ci2,...,ciN representing the
coordianates of the constellation symbol c_i with i=y_k.
</p><pre class="programlisting">
20 mod = gr.chunks_to_symbols_sf(constellation,dimensionality)
</pre><p>
The channel is AWGN with appropriate noise variance.
For each transmitted symbol c_k=(ck1,ck2,...,ckN) we receive a noisy version
r_k=(rk1,rk2,...,rkN).
</p><pre class="programlisting">
22 # CHANNEL
23 add = gr.add_ff()
24 noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)
</pre><p>
Part of the design methodology was to decouple the FSM and VA from
the details of the modulation, channel, receiver front-end etc.
In order for the VA to run, we only need to provide it with
a number representing a cost associated with each transition
in the trellis. Then the VA will find the sequence with
the smallest total cost through the trellis.
The cost associated with a transition (s_k,x_k) is only a function
of the output y_k = OS(s_k,x_k), and the observation
vector r_k. Thus, for each time period, k,
we need to label each of the SxI transitions with such a cost.
This means that for each time period we need to evaluate
O such numbers (one for each possible output symbol y_k).
This is done
in "metrics_f". In particular, metrics_f is a memoryless device
taking N inputs at a time and producing O outputs. The N inputs are
rk1,rk2,...,rkN.
The O outputs
are the costs associated with observations rk1,rk2,...,rkN and
hypothesized output symbols c_1,c_2,...,c_M. For instance,
if we choose to perform soft-input VA, we need to evaluate
the Euclidean distance between r_k and each of c_1,c_2,...,c_M,
for each of the K transmitted symbols.
Other options are available as well; for instance, we can
do hard decision demodulation and feed the VA with
symbol Hamming distances, or even bit Hamming distances, etc.
These are all implemented in "metrics_f".
</p><pre class="programlisting">
26 # RX
27 metrics = trellis.metrics_f(f.O(),dimensionality,constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi
</pre><p>
Now the VA can run once it is supplied by the initial and final states.
The initial state is known to be 0; the final state is usually
forced to some value by padding the information sequence appropriately.
In this example, we always send the the same info sequence (we only randomize noise) so we can evaluate off line the final state and then provide it to the VA (a value of -1 signifies that there is no fixed initial
or final state). The VA outputs the estimates of the symbols x_k which
are then packed to shorts and compared with the transmitted sequence.
</p><pre class="programlisting">
28 va = trellis.viterbi_s(f,K,0,-1) # Put -1 if the Initial/Final states are not set.
29 fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts
30 dst = gr.check_lfsr_32k_s();
</pre><p>
The function returns the number of shorts and the number of shorts in error. Observe that this way the estimated error rate refers to
16-bit-symbol error rate.
</p><pre class="programlisting">
48 return (ntotal,ntotal-nright)
</pre></div><div class="sect1" lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="future"></a>Future Work</h2></div></div><div></div></div><div class="itemizedlist"><ul type="disc"><li><p>
Improve the documentation :-)
</p></li><li><p>
automate fsm generation from generator polynomials
(feedforward or feedback form).
</p></li><li><p>
Optimize the VA code.
</p></li><li><p>
Provide implementation of soft-input soft-output (SISO) decoders for
potential use in concatenated systems. Also a host of suboptimal
decoders, eg, sphere decoding, M- and T- algorithms, sequential decoding, etc.
can be implemented.
</p></li><li><p>
Although turbo decoding is rediculously slow in software,
we can design it in principle. One question is, whether we should
use the encoder, and SISO blocks and connect them
through GNU radio or we should implement turbo-decoding
as a single block (issues with buffering between blocks).
</p></li></ul></div></div></div></body></html>
|
