-#

-# Copyright 2004 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# GNU Radio is free software; you can redistribute it and/or modify

-# it under the terms of the GNU General Public License as published by

-# the Free Software Foundation; either version 3, or (at your option)

-# any later version.

-#

-# GNU Radio is distributed in the hope that it will be useful,

-# but WITHOUT ANY WARRANTY; without even the implied warranty of

-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-# GNU General Public License for more details.

-#

-# You should have received a copy of the GNU General Public License

-# along with GNU Radio; see the file COPYING. If not, write to

-# the Free Software Foundation, Inc., 51 Franklin Street,

-# Boston, MA 02110-1301, USA.

-#

-

-EXTRA_DIST = \

- README \

- fsm_utils.py \

- test_tcm.py \

- test_tcm1.py \

- test_tcm2.py \

- test_tcm_parallel.py \

- test_tcm_combined.py \

- test_sccc_hard.py \

- test_sccc_soft.py \

- test_sccc_turbo.py \

- test_viterbi_equalization1.py \

- test_viterbi_equalization.py \

- test_turbo_equalization.py \

- test_turbo_equalization1.py \

- test_turbo_equalization2.py

-

-SUBDIRS = fsm_files

-

-MOSTLYCLEANFILES = *.pyc

-Here we have several test programs for use with the gr-trellis implementation.

-Documentation can be found in

-http://gnuradio.utah.edu/svn/gnuradio/trunk/gr-trellis/doc/gr-trellis.html

-

-fsm_utils.py contains several useful functions.

-

-fsm_files is a directory with some FSM definitions

-

-If you just want to see what these programs do, run each of the following:

-

-./test_tcm.py fsm_files/awgn1o2_4.fsm 6.0 1000

-./test_tcm1.py fsm_files/awgn1o2_4.fsm 6.0 1000

-./test_tcm2.py 6.0 1000

-./test_tcm_combined.py fsm_files/awgn1o2_4.fsm 6.0 1000

-./test_tcm_parallel.py fsm_files/awgn1o2_4.fsm 6.0 1000

-

-./test_sccc_hard.py fsm_files/awgn1o2_4.fsm fsm_files/awgn2o3_4_msb.fsm 10.0 100

-./test_sccc_soft.py fsm_files/awgn1o2_4.fsm fsm_files/awgn2o3_4_msb.fsm 8.0 100

-./test_sccc_turbo.py fsm_files/awgn1o2_4.fsm fsm_files/awgn2o3_4_msb.fsm 5.0 100

-

-./test_viterbi_equalization.py 12.0 100

-./test_viterbi_equalization1.py 12.0 100

-./test_turbo_equalization1.py fsm_files/awgn1o2_4.fsm 8.0 100

-./test_turbo_equalization2.py fsm_files/awgn1o2_4.fsm 8.0 100

-

-

-In your terminal you will see something like this:

-

-

-$ ./test_tcm.py fsm_files/awgn1o2_4.fsm 6.0 1000

-100 98 9.80e-01 102400 9 8.79e-05

-200 198 9.90e-01 204800 20 9.77e-05

-300 298 9.93e-01 307200 40 1.30e-04

-400 398 9.95e-01 409600 1074 2.62e-03

-500 498 9.96e-01 512000 1081 2.11e-03

-600 598 9.97e-01 614400 1090 1.77e-03

-700 698 9.97e-01 716800 1097 1.53e-03

-800 798 9.98e-01 819200 1107 1.35e-03

-900 898 9.98e-01 921600 1120 1.22e-03

-1000 998 9.98e-01 1024000 1129 1.10e-03

-1000 998 9.98e-01 1024000 1129 1.10e-03

-

-which gives you information about the:

-number of transmitted packets

-number of packets in error

-estimated packet error rate

-number of transmitted shorts (or symbols, or bits, depending on the specific program)

-number of shorts (or symbols, or bits) in error

-estimated short (or symbol, or bit) error rate

-

-for instance, the final number 1.10e-03 is the error rate estimate by sending 1000

-packets of 1024 shorts each, using an 1/2 4-state convolutional code

-and QPSK modulation through an AWGN with Es/N0 = 6.0 dB

-#

-# Copyright 2004 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# GNU Radio is free software; you can redistribute it and/or modify

-# it under the terms of the GNU General Public License as published by

-# the Free Software Foundation; either version 3, or (at your option)

-# any later version.

-#

-# GNU Radio is distributed in the hope that it will be useful,

-# but WITHOUT ANY WARRANTY; without even the implied warranty of

-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-# GNU General Public License for more details.

-#

-# You should have received a copy of the GNU General Public License

-# along with GNU Radio; see the file COPYING. If not, write to

-# the Free Software Foundation, Inc., 51 Franklin Street,

-# Boston, MA 02110-1301, USA.

-#

-

-EXTRA_DIST = \

- awgn1o2_128.fsm \

- awgn1o2_16.fsm \

- awgn1o2_4.fsm \

- awgn1o2_8.fsm \

- awgn2o3_16.fsm \

- awgn2o3_4.fsm \

- awgn2o3_4_msb.fsm \

- awgn2o3_4_msbG.fsm \

- awgn2o3_8.fsm \

- awgn2o4_4.fsm \

- disconnected.fsm \

- rep3.fsm \

- rep5.fsm \

- simple.fsm

-

-2 128 4

-

-0 64

-0 64

-1 65

-1 65

-2 66

-2 66

-3 67

-3 67

-4 68

-4 68

-5 69

-5 69

-6 70

-6 70

-7 71

-7 71

-8 72

-8 72

-9 73

-9 73

-10 74

-10 74

-11 75

-11 75

-12 76

-12 76

-13 77

-13 77

-14 78

-14 78

-15 79

-15 79

-16 80

-16 80

-17 81

-17 81

-18 82

-18 82

-19 83

-19 83

-20 84

-20 84

-21 85

-21 85

-22 86

-22 86

-23 87

-23 87

-24 88

-24 88

-25 89

-25 89

-26 90

-26 90

-27 91

-27 91

-28 92

-28 92

-29 93

-29 93

-30 94

-30 94

-31 95

-31 95

-32 96

-32 96

-33 97

-33 97

-34 98

-34 98

-35 99

-35 99

-36 100

-36 100

-37 101

-37 101

-38 102

-38 102

-39 103

-39 103

-40 104

-40 104

-41 105

-41 105

-42 106

-42 106

-43 107

-43 107

-44 108

-44 108

-45 109

-45 109

-46 110

-46 110

-47 111

-47 111

-48 112

-48 112

-49 113

-49 113

-50 114

-50 114

-51 115

-51 115

-52 116

-52 116

-53 117

-53 117

-54 118

-54 118

-55 119

-55 119

-56 120

-56 120

-57 121

-57 121

-58 122

-58 122

-59 123

-59 123

-60 124

-60 124

-61 125

-61 125

-62 126

-62 126

-63 127

-63 127

-

-0 3

-3 0

-1 2

-2 1

-3 0

-0 3

-2 1

-1 2

-1 2

-2 1

-0 3

-3 0

-2 1

-1 2

-3 0

-0 3

-1 2

-2 1

-0 3

-3 0

-2 1

-1 2

-3 0

-0 3

-0 3

-3 0

-1 2

-2 1

-3 0

-0 3

-2 1

-1 2

-2 1

-1 2

-3 0

-0 3

-1 2

-2 1

-0 3

-3 0

-3 0

-0 3

-2 1

-1 2

-0 3

-3 0

-1 2

-2 1

-3 0

-0 3

-2 1

-1 2

-0 3

-3 0

-1 2

-2 1

-2 1

-1 2

-3 0

-0 3

-1 2

-2 1

-0 3

-3 0

-2 1

-1 2

-3 0

-0 3

-1 2

-2 1

-0 3

-3 0

-3 0

-0 3

-2 1

-1 2

-0 3

-3 0

-1 2

-2 1

-3 0

-0 3

-2 1

-1 2

-0 3

-3 0

-1 2

-2 1

-2 1

-1 2

-3 0

-0 3

-1 2

-2 1

-0 3

-3 0

-0 3

-3 0

-1 2

-2 1

-3 0

-0 3

-2 1

-1 2

-1 2

-2 1

-0 3

-3 0

-2 1

-1 2

-3 0

-0 3

-1 2

-2 1

-0 3

-3 0

-2 1

-1 2

-3 0

-0 3

-0 3

-3 0

-1 2

-2 1

-3 0

-0 3

-2 1

-1 2

-

-

-

-GM1o2_128=[1+D+D^2+D^5+D^7 1+D^3+D^4+D^5+D^6+D^7]

- =[11100101 10011111]

- =[229 159]

-2 16 4

-

-0 8

-0 8

-1 9

-1 9

-2 10

-2 10

-3 11

-3 11

-4 12

-4 12

-5 13

-5 13

-6 14

-6 14

-7 15

-7 15

-

-0 3

-3 0

-1 2

-2 1

-1 2

-2 1

-0 3

-3 0

-2 1

-1 2

-3 0

-0 3

-3 0

-0 3

-2 1

-1 2

-

-

-

-GM1o2_16=[1+D+D^4 1+D^2+D^3+D^4 ] = [25,23] (decimal)

-2 4 4

-

-0 2

-0 2

-1 3

-1 3

-

-0 3

-3 0

-1 2

-2 1

-

-AWGN CC from Proakis-Salehi pg 779

-GM1o2_4=[1+D^2, 1+D+D^2] = [5, 7] (in decimal);

-2 8 4

-

-0 4

-0 4

-1 5

-1 5

-2 6

-2 6

-3 7

-3 7

-

-

-0 3

-3 0

-1 2

-2 1

-3 0

-0 3

-2 1

-1 2

-

-

-1/2 8-state code (Proakis pg. 493)

-GM1o2_8=[ 1+D+D^3 1+D+D^2+D^3] =[13 , 15] (decimal)

-4 16 8

-

-0 8 4 12

-0 8 4 12

-0 8 4 12

-0 8 4 12

-1 9 5 13

-1 9 5 13

-1 9 5 13

-1 9 5 13

-2 10 6 14

-2 10 6 14

-2 10 6 14

-2 10 6 14

-3 11 7 15

-3 11 7 15

-3 11 7 15

-3 11 7 15

-

-0 1 7 6

-6 7 1 0

-3 2 4 5

-5 4 2 3

-2 3 5 4

-4 5 3 2

-1 0 6 7

-7 6 0 1

-4 5 3 2

-2 3 5 4

-7 6 0 1

-1 0 6 7

-6 7 1 0

-0 1 7 6

-5 4 2 3

-3 2 4 5

-

-

-2/3 code generated from the awgn 1/2 code with 16 states and puncturing the 4th bit.

-d_free=

-

-4 4 8

-

-0 1 2 3

-0 1 2 3

-0 1 2 3

-0 1 2 3

-

-0 7 4 3

-3 4 7 0

-5 2 1 6

-6 1 2 5

-

-I don't remeber how I generated this one...

-it is a bit better than awgn2o3_4_msb and worse

-than awgn2o3_4_msbG.

-4 4 8

-

-0 1 2 3

-0 1 2 3

-0 1 2 3

-0 1 2 3

-

-0 5 3 6

-4 1 7 2

-7 2 4 1

-3 6 0 5

-

-

-This is generated by the 1/2 AWGN code (5 7) operated twice, ie,

-(xk+1 xki) [xk-1 xk-2] -> [xk+1 xki].

-We also puncture the first (MSB) bit.

-This code is worse than awgn2o3_4_msbG and slightly worse than

-awgn2o3_4, BUT seems to be a good innner code for sctcm (with 8PSK natural).

-

-intermediate states:

-

-00 21 02 23

-00 21 02 23

-10 31 12 33

-10 31 12 33

-

-output before puncturing:

-

-00 31 03 32

-30 01 33 02

-13 22 10 21

-23 12 20 11

-

-output after punturing the MSB:

-

-00 11 03 12

-10 01 13 02

-13 02 10 01

-03 12 00 11

-

-and in decimal:

-

-0 5 3 6

-4 1 7 2

-7 2 4 1

-3 6 0 5

-4 4 8

-

-0 1 2 3

-0 1 2 3

-0 1 2 3

-0 1 2 3

-

-0 4 2 6

-5 1 3 7

-3 7 5 1

-

-

-This is generated by the 1/2 AWGN code (5 7) operated twice, ie,

-(xk+1 xki) [xk-1 xk-2] -> [xk+1 xki].

-We also puncture the first (MSB) bit and Gray map the symbols.

-

-intermediate states:

-

-00 21 02 23

-00 21 02 23

-10 31 12 33

-10 31 12 33

-

-output before puncturing:

-

-00 31 03 32

-30 01 33 02

-13 22 10 21

-23 12 20 11

-

-output after punturing the MSB:

-

-00 11 03 12

-10 01 13 02

-13 02 10 01

-03 12 00 11

-

-and in decimal:

-

-0 5 3 6

-4 1 7 2

-7 2 4 1

-3 6 0 5

-

-After Gray mapping:

-label -> phase

-0 -> 0

-1 -> 0

-2 -> 7

-3 -> 2

-4 -> 5

-5 -> 4

-6 -> 6

-7 -> 3

-

-0 4 2 6

-5 1 3 7

-3 7 5 1

-2 6 0 4

-

-4 8 8

-

-0 4 2 6

-0 4 2 6

-0 4 2 6

-0 4 2 6

-1 5 3 7

-1 5 3 7

-1 5 3 7

-1 5 3 7

-

-

-0 1 7 6

-6 7 1 0

-3 2 4 5

-5 4 2 3

-6 7 1 0

-0 1 7 6

-5 4 2 3

-3 2 4 5

-

-

-

-This is generated by the 1/2 8-state AWGN code (15 17) by puncturing the fourth bit.

---> d_free=???

-4 4 16

-

-0 1 2 3

-0 1 2 3

-0 1 2 3

-0 1 2 3

-

- 0 13 3 14

-12 1 15 2

- 7 10 4 9

-11 6 8 5

-

-

-This is generated by the 1/2 AWGN code (5 7) operated twice, ie,

-(xk+1 xki) [xk-1 xk-2] -> [xk+1 xki].

-

-intermediate states:

-

-00 21 02 23

-00 21 02 23

-10 31 12 33

-10 31 12 33

-

-output:

-

-00 31 03 32

-30 01 33 02

-13 22 10 21

-23 12 20 11

-

-and in decimal:

-

- 0 13 3 14

-12 1 15 2

- 7 10 4 9

-11 6 8 5

-1 4 1

-

-1

-0

-3

-2

-

-0

-0

-0

-0

-2 2 2

-

-0 0

-0 1

-

-0 1

-0 1

-

-

-useless irregular FSM for testing. state 0 has 3 incoming edges and state

-1 has 1 incoming edge.

-2 1 8

-

-0 0

-

-0 7

-

-1/3 repetition code (with binary input).

-There is only one state, since this is essentially a memoryless system.

-2 1 8

-

-0 0

-

-0 7

-

-1/3 repetiotion code

-1 4 1

-

-1

-2

-3

-0

-

-0

-0

-0

-0

-

-essentially this fsm has no inputs and no outputs; it ijust cycles through all 4 states.

-#!/usr/bin/env python

-#

-# Copyright 2004 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# GNU Radio is free software; you can redistribute it and/or modify

-# it under the terms of the GNU General Public License as published by

-# the Free Software Foundation; either version 3, or (at your option)

-# any later version.

-#

-# GNU Radio is distributed in the hope that it will be useful,

-# but WITHOUT ANY WARRANTY; without even the implied warranty of

-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-# GNU General Public License for more details.

-#

-# You should have received a copy of the GNU General Public License

-# along with GNU Radio; see the file COPYING. If not, write to

-# the Free Software Foundation, Inc., 51 Franklin Street,

-# Boston, MA 02110-1301, USA.

-#

-

-

-import re

-import math

-import sys

-import operator

-

-from gnuradio import trellis

-

-

-

-######################################################################

-# Decimal to any base conversion.

-# Convert 'num' to a list of 'l' numbers representing 'num'

-# to base 'base' (most significant symbol first).

-######################################################################

-def dec2base(num,base,l):

- s=range(l)

- n=num

- for i in range(l):

- s[l-i-1]=n%base

- n=int(n/base)

- if n!=0:

- print 'Number ', num, ' requires more than ', l, 'digits.'

- return s

-

-

-######################################################################

-# Conversion from any base to decimal.

-# Convert a list 's' of symbols to a decimal number

-# (most significant symbol first)

-######################################################################

-def base2dec(s,base):

- num=0

- for i in range(len(s)):

- num=num*base+s[i]

- return num

-

-

-######################################################################

-# Generate a new FSM representing the concatenation of two FSMs

-######################################################################

-def fsm_concatenate(f1,f2):

- if f1.O() > f2.I():

- print "Not compatible FSMs\n"

- I=f1.I()

- S=f1.S()*f2.S()

- O=f2.O()

- nsm=list([0]*I*S)

- osm=list([0]*I*S)

- for s1 in range(f1.S()):

- for s2 in range(f2.S()):

- for i in range(f1.I()):

- ns1=f1.NS()[s1*f1.I()+i]

- o1=f1.OS()[s1*f1.I()+i]

- ns2=f2.NS()[s2*f2.I()+o1]

- o2=f2.OS()[s2*f2.I()+o1]

-

- s=s1*f2.S()+s2

- ns=ns1*f2.S()+ns2

- nsm[s*I+i]=ns

- osm[s*I+i]=o2

-

-

- f=trellis.fsm(I,S,O,nsm,osm)

- return f

-

-######################################################################

-# Generate a new FSM representing n stages through the original FSM

-######################################################################

-def fsm_radix(f,n):

- I=f.I()**n

- S=f.S()

- O=f.O()**n

- nsm=list([0]*I*S)

- osm=list([0]*I*S)

- for s in range(f.S()):

- for i in range(I):

- ii=dec2base(i,f.I(),n)

- oo=list([0]*n)

- ns=s

- for k in range(n):

- oo[k]=f.OS()[ns*f.I()+ii[k]]

- ns=f.NS()[ns*f.I()+ii[k]]

-

- nsm[s*I+i]=ns

- osm[s*I+i]=base2dec(oo,f.O())

-

-

- f=trellis.fsm(I,S,O,nsm,osm)

- return f

-

-

-

-

-######################################################################

-# Automatically generate the lookup table that maps the FSM outputs

-# to channel inputs corresponding to a channel 'channel' and a modulation

-# 'mod'. Optional normalization of channel to unit energy.

-# This table is used by the 'metrics' block to translate

-# channel outputs to metrics for use with the Viterbi algorithm.

-# Limitations: currently supports only one-dimensional modulations.

-######################################################################

-def make_isi_lookup(mod,channel,normalize):

- dim=mod[0]

- constellation = mod[1]

-

- if normalize:

- p = 0

- for i in range(len(channel)):

- p = p + channel[i]**2

- for i in range(len(channel)):

- channel[i] = channel[i]/math.sqrt(p)

-

- lookup=range(len(constellation)**len(channel))

- for o in range(len(constellation)**len(channel)):

- ss=dec2base(o,len(constellation),len(channel))

- ll=0

- for i in range(len(channel)):

- ll=ll+constellation[ss[i]]*channel[i]

- lookup[o]=ll

- return (1,lookup)

-

-

-

-

-

-

-######################################################################

-# A list of common modulations.

-# Format: (dimensionality,constellation)

-######################################################################

-pam2 = (1,[-1, 1])

-pam4 = (1,[-3, -1, 3, 1]) # includes Gray mapping

-pam8 = (1,[-7, -5, -3, -1, 1, 3, 5, 7])

-

-psk4=(2,[1, 0, \

- 0, 1, \

- 0, -1,\

- -1, 0]) # includes Gray mapping

-psk8=(2,[math.cos(2*math.pi*0/8), math.sin(2*math.pi*0/8), \

- math.cos(2*math.pi*1/8), math.sin(2*math.pi*1/8), \

- math.cos(2*math.pi*2/8), math.sin(2*math.pi*2/8), \

- math.cos(2*math.pi*3/8), math.sin(2*math.pi*3/8), \

- math.cos(2*math.pi*4/8), math.sin(2*math.pi*4/8), \

- math.cos(2*math.pi*5/8), math.sin(2*math.pi*5/8), \

- math.cos(2*math.pi*6/8), math.sin(2*math.pi*6/8), \

- math.cos(2*math.pi*7/8), math.sin(2*math.pi*7/8)])

-

-orth2 = (2,[1, 0, \

- 0, 1])

-orth4=(4,[1, 0, 0, 0, \

- 0, 1, 0, 0, \

- 0, 0, 1, 0, \

- 0, 0, 0, 1])

-

-######################################################################

-# A list of channels to be tested

-######################################################################

-

-# C test channel (J. Proakis, Digital Communications, McGraw-Hill Inc., 2001)

-c_channel = [0.227, 0.460, 0.688, 0.460, 0.227]

-

-

-

-

-

-

-

-

-

-

-if __name__ == '__main__':

- f1=trellis.fsm('fsm_files/awgn1o2_4.fsm')

- #f2=trellis.fsm('fsm_files/awgn2o3_4.fsm')

- print f1.I(), f1.S(), f1.O()

- print f1.NS()

- print f1.OS()

- #print f2.I(), f2.S(), f2.O()

- #print f2.NS()

- #print f2.OS()

- ##f1.write_trellis_svg('f1.svg',4)

- #f2.write_trellis_svg('f2.svg',4)

- #f=fsm_concatenate(f1,f2)

- f=fsm_radix(f1,2)

-

- print "----------\n"

- print f.I(), f.S(), f.O()

- print f.NS()

- print f.OS()

- #f.write_trellis_svg('f.svg',4)

-

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import random

-import fsm_utils

-

-def run_test (fo,fi,interleaver,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed):

- fg = gr.flow_graph ()

-

-

- # TX

- src = gr.lfsr_32k_source_s()

- src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts

- s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the outer FSM input cardinality

- enc_out = trellis.encoder_ss(fo,0) # initial state = 0

- inter = trellis.permutation(interleaver.K(),interleaver.INTER(),1,gr.sizeof_short)

- enc_in = trellis.encoder_ss(fi,0) # initial state = 0

- mod = gr.chunks_to_symbols_sf(constellation,dimensionality)

-

- # CHANNEL

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

- # RX

- metrics_in = trellis.metrics_f(fi.O(),dimensionality,constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for innner Viterbi

- va_in = trellis.viterbi_s(fi,K,0,-1) # Put -1 if the Initial/Final states are not set.

- deinter = trellis.permutation(interleaver.K(),interleaver.DEINTER(),1,gr.sizeof_short)

- metrics_out = trellis.metrics_s(fo.O(),1,[0,1,2,3],trellis.TRELLIS_HARD_SYMBOL) # data preprocessing to generate metrics for outer Viterbi (hard decisions)

- va_out = trellis.viterbi_s(fo,K,0,-1) # Put -1 if the Initial/Final states are not set.

- fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts

- dst = gr.check_lfsr_32k_s()

-

- fg.connect (src,src_head,s2fsmi,enc_out,inter,enc_in,mod)

- fg.connect (mod,(add,0))

- fg.connect (noise,(add,1))

- fg.connect (add,metrics_in)

- fg.connect (metrics_in,va_in,deinter,metrics_out,va_out,fsmi2s,dst)

-

- fg.run()

-

- ntotal = dst.ntotal ()

- nright = dst.nright ()

- runlength = dst.runlength ()

- return (ntotal,ntotal-nright)

-

-

-def main(args):

- nargs = len (args)

- if nargs == 4:

- fname_out=args[0]

- fname_in=args[1]

- esn0_db=float(args[2]) # Es/No in dB

- rep=int(args[3]) # number of times the experiment is run to collect enough errors

- else:

- sys.stderr.write ('usage: test_tcm.py fsm_name_out fsm_fname_in Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- Kb=1024*16 # packet size in bits (make it multiple of 16 so it can be packed in a short)

- fo=trellis.fsm(fname_out) # get the outer FSM specification from a file

- fi=trellis.fsm(fname_in) # get the innner FSM specification from a file

- bitspersymbol = int(round(math.log(fo.I())/math.log(2))) # bits per FSM input symbol

- if fo.O() != fi.I():

- sys.stderr.write ('Incompatible cardinality between outer and inner FSM.\n')

- sys.exit (1)

- K=Kb/bitspersymbol # packet size in trellis steps

- interleaver=trellis.interleaver(K,666) # construct a random interleaver

- modulation = fsm_utils.psk8 # see fsm_utlis.py for available predefined modulations

- dimensionality = modulation[0]

- constellation = modulation[1]

- if len(constellation)/dimensionality != fi.O():

- sys.stderr.write ('Incompatible FSM output cardinality and modulation size.\n')

- sys.exit (1)

- # calculate average symbol energy

- Es = 0

- for i in range(len(constellation)):

- Es = Es + constellation[i]**2

- Es = Es / (len(constellation)/dimensionality)

- N0=Es/pow(10.0,esn0_db/10.0); # calculate noise variance

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

- for i in range(rep):

- (s,e)=run_test(fo,fi,interleaver,Kb,bitspersymbol,K,dimensionality,constellation,N0,-long(666+i)) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%100==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import random

-import fsm_utils

-

-

-

-

-def run_test (fo,fi,interleaver,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed):

- fg = gr.flow_graph ()

-

-

- # TX

- src = gr.lfsr_32k_source_s()

- src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts

- s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the outer FSM input cardinality

- enc_out = trellis.encoder_ss(fo,0) # initial state = 0

- inter = trellis.permutation(interleaver.K(),interleaver.INTER(),1,gr.sizeof_short)

- enc_in = trellis.encoder_ss(fi,0) # initial state = 0

- mod = gr.chunks_to_symbols_sf(constellation,dimensionality)

-

- # CHANNEL

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

- # RX

- metrics_in = trellis.metrics_f(fi.O(),dimensionality,constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for innner Viterbi

- gnd = gr.vector_source_f([0],True);

- siso_in = trellis.siso_f(fi,K,0,-1,True,False,trellis.TRELLIS_MIN_SUM) # Put -1 if the Initial/Final states are not set.

- deinter = trellis.permutation(interleaver.K(),interleaver.DEINTER(),fi.I(),gr.sizeof_float)

- va_out = trellis.viterbi_s(fo,K,0,-1) # Put -1 if the Initial/Final states are not set.

- fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts

- dst = gr.check_lfsr_32k_s()

-

- fg.connect (src,src_head,s2fsmi,enc_out,inter,enc_in,mod)

- fg.connect (mod,(add,0))

- fg.connect (noise,(add,1))

- fg.connect (add,metrics_in)

- fg.connect (gnd,(siso_in,0))

- fg.connect (metrics_in,(siso_in,1))

- fg.connect (siso_in,deinter,va_out,fsmi2s,dst)

-

- fg.run()

-

- ntotal = dst.ntotal ()

- nright = dst.nright ()

- runlength = dst.runlength ()

- return (ntotal,ntotal-nright)

-

-

-def main(args):

- nargs = len (args)

- if nargs == 4:

- fname_out=args[0]

- fname_in=args[1]

- esn0_db=float(args[2]) # Es/No in dB

- rep=int(args[3]) # number of times the experiment is run to collect enough errors

- else:

- sys.stderr.write ('usage: test_tcm.py fsm_name_out fsm_fname_in Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- Kb=1024*16 # packet size in bits (make it multiple of 16 so it can be packed in a short)

- fo=trellis.fsm(fname_out) # get the outer FSM specification from a file

- fi=trellis.fsm(fname_in) # get the innner FSM specification from a file

- bitspersymbol = int(round(math.log(fo.I())/math.log(2))) # bits per FSM input symbol

- if fo.O() != fi.I():

- sys.stderr.write ('Incompatible cardinality between outer and inner FSM.\n')

- sys.exit (1)

- K=Kb/bitspersymbol # packet size in trellis steps

- interleaver=trellis.interleaver(K,666) # construct a random interleaver

- modulation = fsm_utils.psk8 # see fsm_utlis.py for available predefined modulations

- dimensionality = modulation[0]

- constellation = modulation[1]

- if len(constellation)/dimensionality != fi.O():

- sys.stderr.write ('Incompatible FSM output cardinality and modulation size.\n')

- sys.exit (1)

- # calculate average symbol energy

- Es = 0

- for i in range(len(constellation)):

- Es = Es + constellation[i]**2

- Es = Es / (len(constellation)/dimensionality)

- N0=Es/pow(10.0,esn0_db/10.0); # calculate noise variance

-

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

- for i in range(rep):

- (s,e)=run_test(fo,fi,interleaver,Kb,bitspersymbol,K,dimensionality,constellation,N0,-long(666+i)) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%100==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import random

-import fsm_utils

-

-

-

-def make_rx(fg,fo,fi,dimensionality,constellation,K,interleaver,IT,Es,N0,type):

- metrics_in = trellis.metrics_f(fi.O(),dimensionality,constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for innner Viterbi

- scale = gr.multiply_const_ff(1.0/N0)

- gnd = gr.vector_source_f([0],True);

-

- inter=[]

- deinter=[]

- siso_in=[]

- siso_out=[]

-

- # generate all blocks

- for it in range(IT):

- inter.append( trellis.permutation(interleaver.K(),interleaver.INTER(),fi.I(),gr.sizeof_float) )

- siso_in.append( trellis.siso_f(fi,K,0,-1,True,False,type) )

- deinter.append( trellis.permutation(interleaver.K(),interleaver.DEINTER(),fi.I(),gr.sizeof_float) )

- if it < IT-1:

- siso_out.append( trellis.siso_f(fo,K,0,-1,False,True,type) )

- else:

- siso_out.append( trellis.viterbi_s(fo,K,0,-1) ) # no soft outputs needed

-

- # connect first stage

- fg.connect (gnd,inter[0])

- fg.connect (metrics_in,scale)

- fg.connect (scale,(siso_in[0],1))

-

- # connect the rest

- for it in range(IT):

- if it < IT-1:

- fg.connect (metrics_in,(siso_in[it+1],1))

- fg.connect (siso_in[it],deinter[it],(siso_out[it],1))

- fg.connect (gnd,(siso_out[it],0))

- fg.connect (siso_out[it],inter[it+1])

- fg.connect (inter[it],(siso_in[it],0))

- else:

- fg.connect (siso_in[it],deinter[it],siso_out[it])

- fg.connect (inter[it],(siso_in[it],0))

-

- return (metrics_in,siso_out[IT-1])

-

-

-def run_test (fo,fi,interleaver,Kb,bitspersymbol,K,dimensionality,constellation,Es,N0,IT,seed):

- fg = gr.flow_graph ()

-

-

- # TX

- src = gr.lfsr_32k_source_s()

- src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts

- s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the outer FSM input cardinality

- enc_out = trellis.encoder_ss(fo,0) # initial state = 0

- inter = trellis.permutation(interleaver.K(),interleaver.INTER(),1,gr.sizeof_short)

- enc_in = trellis.encoder_ss(fi,0) # initial state = 0

- mod = gr.chunks_to_symbols_sf(constellation,dimensionality)

-

- # CHANNEL

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

- # RX

- (head,tail) = make_rx(fg,fo,fi,dimensionality,constellation,K,interleaver,IT,Es,N0,trellis.TRELLIS_MIN_SUM)

- #(head,tail) = make_rx(fg,fo,fi,dimensionality,constellation,K,interleaver,IT,Es,N0,trellis.TRELLIS_SUM_PRODUCT)

- fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts

- dst = gr.check_lfsr_32k_s()

-

- fg.connect (src,src_head,s2fsmi,enc_out,inter,enc_in,mod)

- fg.connect (mod,(add,0))

- fg.connect (noise,(add,1))

- fg.connect (add,head)

- fg.connect (tail,fsmi2s,dst)

-

- fg.run()

-

- #print enc_out.ST(), enc_in.ST()

-

- ntotal = dst.ntotal ()

- nright = dst.nright ()

- runlength = dst.runlength ()

- return (ntotal,ntotal-nright)

-

-

-def main(args):

- nargs = len (args)

- if nargs == 4:

- fname_out=args[0]

- fname_in=args[1]

- esn0_db=float(args[2]) # Es/No in dB

- rep=int(args[3]) # number of times the experiment is run to collect enough errors

- else:

- sys.stderr.write ('usage: test_tcm.py fsm_name_out fsm_fname_in Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- Kb=1024*16 # packet size in bits (make it multiple of 16 so it can be packed in a short)

- fo=trellis.fsm(fname_out) # get the outer FSM specification from a file

- fi=trellis.fsm(fname_in) # get the innner FSM specification from a file

- bitspersymbol = int(round(math.log(fo.I())/math.log(2))) # bits per FSM input symbol

- if fo.O() != fi.I():

- sys.stderr.write ('Incompatible cardinality between outer and inner FSM.\n')

- sys.exit (1)

- K=Kb/bitspersymbol # packet size in trellis steps

- interleaver=trellis.interleaver(K,666) # construct a random interleaver

- modulation = fsm_utils.psk8 # see fsm_utlis.py for available predefined modulations

- dimensionality = modulation[0]

- constellation = modulation[1]

- if len(constellation)/dimensionality != fi.O():

- sys.stderr.write ('Incompatible FSM output cardinality and modulation size.\n')

- sys.exit (1)

- # calculate average symbol energy

- Es = 0

- for i in range(len(constellation)):

- Es = Es + constellation[i]**2

- Es = Es / (len(constellation)/dimensionality)

- N0=Es/pow(10.0,esn0_db/10.0); # calculate noise variance

- IT = 3 # number of turbo iterations

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

- for i in range(rep):

- (s,e)=run_test(fo,fi,interleaver,Kb,bitspersymbol,K,dimensionality,constellation,Es,N0,IT,-long(666+i)) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%10==0): # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import random

-import fsm_utils

-

-def run_test (f,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed):

- fg = gr.flow_graph ()

-

-

- # TX

- #packet = [0]*Kb

- #for i in range(Kb-1*16): # last 16 bits = 0 to drive the final state to 0

- #packet[i] = random.randint(0, 1) # random 0s and 1s

- #src = gr.vector_source_s(packet,False)

- src = gr.lfsr_32k_source_s()

- src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts

- #b2s = gr.unpacked_to_packed_ss(1,gr.GR_MSB_FIRST) # pack bits in shorts

- s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality

- enc = trellis.encoder_ss(f,0) # initial state = 0

- mod = gr.chunks_to_symbols_sf(constellation,dimensionality)

-

- # CHANNEL

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

- # RX

- metrics = trellis.metrics_f(f.O(),dimensionality,constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi

- va = trellis.viterbi_s(f,K,0,-1) # Put -1 if the Initial/Final states are not set.

- fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts

- #s2b = gr.packed_to_unpacked_ss(1,gr.GR_MSB_FIRST) # unpack shorts to bits

- #dst = gr.vector_sink_s();

- dst = gr.check_lfsr_32k_s()

-

-

- fg.connect (src,src_head,s2fsmi,enc,mod)

- #fg.connect (src,b2s,s2fsmi,enc,mod)

- fg.connect (mod,(add,0))

- fg.connect (noise,(add,1))

- fg.connect (add,metrics)

- fg.connect (metrics,va,fsmi2s,dst)

- #fg.connect (metrics,va,fsmi2s,s2b,dst)

-

-

- fg.run()

-

- # A bit of cheating: run the program once and print the

- # final encoder state..

- # Then put it as the last argument in the viterbi block

- #print "final state = " , enc.ST()

-

- ntotal = dst.ntotal ()

- nright = dst.nright ()

- runlength = dst.runlength ()

- #ntotal = len(packet)

- #if len(dst.data()) != ntotal:

- #print "Error: not enough data\n"

- #nright = 0;

- #for i in range(ntotal):

- #if packet[i]==dst.data()[i]:

- #nright=nright+1

- #else:

- #print "Error in ", i

- return (ntotal,ntotal-nright)

-

-

-

-

-def main(args):

- nargs = len (args)

- if nargs == 3:

- fname=args[0]

- esn0_db=float(args[1]) # Es/No in dB

- rep=int(args[2]) # number of times the experiment is run to collect enough errors

- else:

- sys.stderr.write ('usage: test_tcm.py fsm_fname Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- f=trellis.fsm(fname) # get the FSM specification from a file

- Kb=1024*16 # packet size in bits (make it multiple of 16 so it can be packed in a short)

- bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol

- K=Kb/bitspersymbol # packet size in trellis steps

- modulation = fsm_utils.psk4 # see fsm_utlis.py for available predefined modulations

- dimensionality = modulation[0]

- constellation = modulation[1]

- if len(constellation)/dimensionality != f.O():

- sys.stderr.write ('Incompatible FSM output cardinality and modulation size.\n')

- sys.exit (1)

- # calculate average symbol energy

- Es = 0

- for i in range(len(constellation)):

- Es = Es + constellation[i]**2

- Es = Es / (len(constellation)/dimensionality)

- N0=Es/pow(10.0,esn0_db/10.0); # calculate noise variance

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

- for i in range(rep):

- (s,e)=run_test(f,Kb,bitspersymbol,K,dimensionality,constellation,N0,-long(666+i)) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%100==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import random

-import fsm_utils

-

-def run_test (f,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed):

- fg = gr.flow_graph ()

-

- # TX

- packet = [0]*Kb

- # this for loop is TOO slow!!!

- for i in range(Kb-1*16): # last 16 bits = 0 to drive the final state to 0

- packet[i] = random.randint(0, 1) # random 0s and 1s

- src = gr.vector_source_s(packet,False)

- #src = gr.lfsr_32k_source_s()

- #src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts

- b2s = gr.unpacked_to_packed_ss(1,gr.GR_MSB_FIRST) # pack bits in shorts

- s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality

- enc = trellis.encoder_ss(f,0) # initial state = 0

- mod = gr.chunks_to_symbols_sf(constellation,dimensionality)

-

-

- # CHANNEL

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

-

- # RX

- metrics = trellis.metrics_f(f.O(),dimensionality,constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi

- va = trellis.viterbi_s(f,K,0,-1) # Put -1 if the Initial/Final states are not set.

- fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts

- s2b = gr.packed_to_unpacked_ss(1,gr.GR_MSB_FIRST) # unpack shorts to bits

- dst = gr.vector_sink_s();

- #dst = gr.check_lfsr_32k_s();

-

-

- #fg.connect (src,src_head,s2fsmi,enc,mod)

- fg.connect (src,b2s,s2fsmi,enc,mod)

- fg.connect (mod,(add,0))

- fg.connect (noise,(add,1))

- fg.connect (add,metrics)

- #fg.connect (metrics,va,fsmi2s,dst)

- fg.connect (metrics,va,fsmi2s,s2b,dst)

-

-

- fg.run()

-

- # A bit of cheating: run the program once and print the

- # final encoder state..

- # Then put it as the last argument in the viterbi block

- #print "final state = " , enc.ST()

-

- #ntotal = dst.ntotal ()

- #nright = dst.nright ()

- #runlength = dst.runlength ()

- ntotal = len(packet)

- if len(dst.data()) != ntotal:

- print "Error: not enough data\n"

- nright = 0;

- # this for loop is TOO slow!!!

- for i in range(ntotal):

- if packet[i]==dst.data()[i]:

- nright=nright+1

- #else:

- #print "Error in ", i

- return (ntotal,ntotal-nright)

-

-

-

-

-def main(args):

- nargs = len (args)

- if nargs == 3:

- fname=args[0]

- esn0_db=float(args[1]) # Es/No in dB

- rep=int(args[2]) # number of times the experiment is run to collect enough errors

- else:

- sys.stderr.write ('usage: test_tcm.py fsm_fname Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- f=trellis.fsm(fname) # get the FSM specification from a file

- Kb=1024*16 # packet size in bits (make it multiple of 16 so it can be packed in a short)

- bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol

- K=Kb/bitspersymbol # packet size in trellis steps

- modulation = fsm_utils.psk4 # see fsm_utlis.py for available predefined modulations

- dimensionality = modulation[0]

- constellation = modulation[1]

- if len(constellation)/dimensionality != f.O():

- sys.stderr.write ('Incompatible FSM output cardinality and modulation size.\n')

- sys.exit (1)

- # calculate average symbol energy

- Es = 0

- for i in range(len(constellation)):

- Es = Es + constellation[i]**2

- Es = Es / (len(constellation)/dimensionality)

- N0=Es/pow(10.0,esn0_db/10.0); # noise variance

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

- for i in range(rep):

- (s,e)=run_test(f,Kb,bitspersymbol,K,dimensionality,constellation,N0,-long(666+i)) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%1==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import random

-import fsm_utils

-

-def run_test (f,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed):

- fg = gr.flow_graph ()

-

-

- # TX

- #packet = [0]*Kb

- #for i in range(Kb-1*16): # last 16 bits = 0 to drive the final state to 0

- #packet[i] = random.randint(0, 1) # random 0s and 1s

- #src = gr.vector_source_s(packet,False)

- src = gr.lfsr_32k_source_s()

- src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts

- #b2s = gr.unpacked_to_packed_ss(1,gr.GR_MSB_FIRST) # pack bits in shorts

- s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality

- enc = trellis.encoder_ss(f,0) # initial state = 0

- mod = gr.chunks_to_symbols_sf(constellation,dimensionality)

-

- # CHANNEL

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

- # RX

- metrics = trellis.metrics_f(f.O(),dimensionality,constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi

- va = trellis.viterbi_s(f,K,0,-1) # Put -1 if the Initial/Final states are not set.

- fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts

- #s2b = gr.packed_to_unpacked_ss(1,gr.GR_MSB_FIRST) # unpack shorts to bits

- #dst = gr.vector_sink_s();

- dst = gr.check_lfsr_32k_s()

-

-

- fg.connect (src,src_head,s2fsmi,enc,mod)

- #fg.connect (src,b2s,s2fsmi,enc,mod)

- fg.connect (mod,(add,0))

- fg.connect (noise,(add,1))

- fg.connect (add,metrics)

- fg.connect (metrics,va,fsmi2s,dst)

- #fg.connect (metrics,va,fsmi2s,s2b,dst)

-

-

- fg.run()

-

- # A bit of cheating: run the program once and print the

- # final encoder state..

- # Then put it as the last argument in the viterbi block

- #print "final state = " , enc.ST()

-

- ntotal = dst.ntotal ()

- nright = dst.nright ()

- runlength = dst.runlength ()

- #ntotal = len(packet)

- #if len(dst.data()) != ntotal:

- #print "Error: not enough data\n"

- #nright = 0;

- #for i in range(ntotal):

- #if packet[i]==dst.data()[i]:

- #nright=nright+1

- #else:

- #print "Error in ", i

- return (ntotal,ntotal-nright)

-

-

-

-

-def main(args):

- nargs = len (args)

- if nargs == 2:

- esn0_db=float(args[0]) # Es/No in dB

- rep=int(args[1]) # number of times the experiment is run to collect enough errors

- else:

- sys.stderr.write ('usage: test_tcm2.py Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- f=trellis.fsm(1,2,[5,7]) # generate FSM specification from the generator matrix

- Kb=1024*16 # packet size in bits (make it multiple of 16 so it can be packed in a short)

- bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol

- K=Kb/bitspersymbol # packet size in trellis steps

- modulation = fsm_utils.psk4 # see fsm_utlis.py for available predefined modulations

- dimensionality = modulation[0]

- constellation = modulation[1]

- if len(constellation)/dimensionality != f.O():

- sys.stderr.write ('Incompatible FSM output cardinality and modulation size.\n')

- sys.exit (1)

- # calculate average symbol energy

- Es = 0

- for i in range(len(constellation)):

- Es = Es + constellation[i]**2

- Es = Es / (len(constellation)/dimensionality)

- N0=Es/pow(10.0,esn0_db/10.0); # calculate noise variance

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

- for i in range(rep):

- (s,e)=run_test(f,Kb,bitspersymbol,K,dimensionality,constellation,N0,-long(666+i)) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%100==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import fsm_utils

-

-def run_test (f,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed):

- fg = gr.flow_graph ()

-

- # TX

- src = gr.lfsr_32k_source_s()

- src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts

- s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality

- enc = trellis.encoder_ss(f,0) # initial state = 0

- mod = gr.chunks_to_symbols_sf(constellation,dimensionality)

-

-

- # CHANNEL

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

-

- # RX

- va = trellis.viterbi_combined_fs(f,K,0,-1,dimensionality,constellation,trellis.TRELLIS_EUCLIDEAN) # Put -1 if the Initial/Final states are not set.

- fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts

- dst = gr.check_lfsr_32k_s();

-

-

- fg.connect (src,src_head,s2fsmi,enc,mod)

- fg.connect (mod,(add,0))

- fg.connect (noise,(add,1))

- fg.connect (add,va,fsmi2s,dst)

-

-

- fg.run()

-

- # A bit of cheating: run the program once and print the

- # final encoder state..

- # Then put it as the last argument in the viterbi block

- #print "final state = " , enc.ST()

-

- ntotal = dst.ntotal ()

- nright = dst.nright ()

- runlength = dst.runlength ()

-

- return (ntotal,ntotal-nright)

-

-

-

-

-def main(args):

- nargs = len (args)

- if nargs == 3:

- fname=args[0]

- esn0_db=float(args[1]) # Es/No in dB

- rep=int(args[2]) # number of times the experiment is run to collect enough errors

- else:

- sys.stderr.write ('usage: test_tcm_combined.py fsm_fname Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- f=trellis.fsm(fname) # get the FSM specification from a file (will hopefully be automated in the future...)

- Kb=1024*16 # packet size in bits (make it multiple of 16)

- bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol

- K=Kb/bitspersymbol # packet size in trellis steps

- modulation = fsm_utils.psk4 # see fsm_utils.py for available predefined modulations

- dimensionality = modulation[0]

- constellation = modulation[1]

- if len(constellation)/dimensionality != f.O():

- sys.stderr.write ('Incompatible FSM output cardinality and modulation size.\n')

- sys.exit (1)

- # calculate average symbol energy

- Es = 0

- for i in range(len(constellation)):

- Es = Es + constellation[i]**2

- Es = Es / (len(constellation)/dimensionality)

- N0=Es/pow(10.0,esn0_db/10.0); # noise variance

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

- for i in range(rep):

- (s,e)=run_test(f,Kb,bitspersymbol,K,dimensionality,constellation,N0,-long(666+i)) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%100==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import fsm_utils

-

-def run_test (f,Kb,bitspersymbol,K,dimensionality,constellation,N0,seed,P):

- fg = gr.flow_graph ()

-

- # TX

- src = gr.lfsr_32k_source_s()

- src_head = gr.head (gr.sizeof_short,Kb/16*P) # packet size in shorts

- s2fsmi=gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality

- s2p = gr.stream_to_streams(gr.sizeof_short,P) # serial to parallel

- enc = trellis.encoder_ss(f,0) # initiali state = 0

- mod = gr.chunks_to_symbols_sf(constellation,dimensionality)

-

- # CHANNEL

- add=[]

- noise=[]

- for i in range(P):

- add.append(gr.add_ff())

- noise.append(gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed))

-

- # RX

- metrics = trellis.metrics_f(f.O(),dimensionality,constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi

- va = trellis.viterbi_s(f,K,0,-1) # Put -1 if the Initial/Final states are not set.

- p2s = gr.streams_to_stream(gr.sizeof_short,P) # parallel to serial

- fsmi2s=gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts

- dst = gr.check_lfsr_32k_s()

-

- fg.connect (src,src_head,s2fsmi,s2p)

- for i in range(P):

- fg.connect ((s2p,i),(enc,i),(mod,i))

- fg.connect ((mod,i),(add[i],0))

- fg.connect (noise[i],(add[i],1))

- fg.connect (add[i],(metrics,i))

- fg.connect ((metrics,i),(va,i),(p2s,i))

- fg.connect (p2s,fsmi2s,dst)

-

-

- fg.run()

-

- # A bit of cheating: run the program once and print the

- # final encoder state.

- # Then put it as the last argument in the viterbi block

- #print "final state = " , enc.ST()

-

- ntotal = dst.ntotal ()

- nright = dst.nright ()

- runlength = dst.runlength ()

-

- return (ntotal,ntotal-nright)

-

-

-

-def main(args):

- nargs = len (args)

- if nargs == 3:

- fname=args[0]

- esn0_db=float(args[1]) # Es/No in dB

- rep=int(args[2]) # number of times the experiment is run to collect enough errors

- else:

- sys.stderr.write ('usage: test_tcm.py fsm_fname Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- f=trellis.fsm(fname) # get the FSM specification from a file

- P=4 # how many parallel streams?

- Kb=1024*16 # packet size in bits (make it multiple of 16 so it can be packed in a short)

- bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol

- K=Kb/bitspersymbol # packet size in trellis steps

- modulation = fsm_utils.psk4 # see fsm_utlis.py for available predefined modulations

- dimensionality = modulation[0]

- constellation = modulation[1]

- if len(constellation)/dimensionality != f.O():

- sys.stderr.write ('Incompatible FSM output cardinality and modulation size.\n')

- sys.exit (1)

- # calculate average symbol energy

- Es = 0

- for i in range(len(constellation)):

- Es = Es + constellation[i]**2

- Es = Es / (len(constellation)/dimensionality)

- N0=Es/pow(10.0,esn0_db/10.0); # calculate noise variance

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

- for i in range(rep):

- (s,e)=run_test(f,Kb,bitspersymbol,K,dimensionality,constellation,N0,-long(666+i),P) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%100==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import fsm_utils

-

-

-def make_rx(fg,fo,fi,dimensionality,tot_constellation,K,interleaver,IT,Es,N0,type):

- metrics_in = trellis.metrics_f(fi.O(),dimensionality,tot_constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for innner SISO

- scale = gr.multiply_const_ff(1.0/N0)

- gnd = gr.vector_source_f([0],True);

-

- inter=[]

- deinter=[]

- siso_in=[]

- siso_out=[]

-

- # generate all blocks

- for it in range(IT):

- inter.append( trellis.permutation(interleaver.K(),interleaver.INTER(),fi.I(),gr.sizeof_float) )

- siso_in.append( trellis.siso_f(fi,K,0,-1,True,False,type) )

- deinter.append( trellis.permutation(interleaver.K(),interleaver.DEINTER(),fi.I(),gr.sizeof_float) )

- if it < IT-1:

- siso_out.append( trellis.siso_f(fo,K,0,-1,False,True,type) )

- else:

- siso_out.append( trellis.viterbi_s(fo,K,0,-1) ) # no soft outputs needed

-

- # connect first stage

- fg.connect (gnd,inter[0])

- fg.connect (metrics_in,scale)

- fg.connect (scale,(siso_in[0],1))

-

- # connect the rest

- for it in range(IT):

- if it < IT-1:

- fg.connect (metrics_in,(siso_in[it+1],1))

- fg.connect (siso_in[it],deinter[it],(siso_out[it],1))

- fg.connect (gnd,(siso_out[it],0))

- fg.connect (siso_out[it],inter[it+1])

- fg.connect (inter[it],(siso_in[it],0))

- else:

- fg.connect (siso_in[it],deinter[it],siso_out[it])

- fg.connect (inter[it],(siso_in[it],0))

-

- return (metrics_in,siso_out[IT-1])

-

-

-def run_test (fo,fi,interleaver,Kb,bitspersymbol,K,dimensionality,tot_constellation,Es,N0,IT,seed):

- fg = gr.flow_graph ()

-

- # TX

- src = gr.lfsr_32k_source_s()

- src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts

- s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the iouter FSM input cardinality

- enc_out = trellis.encoder_ss(fo,0) # initial state = 0

- inter = trellis.permutation(interleaver.K(),interleaver.INTER(),1,gr.sizeof_short)

- enc_in = trellis.encoder_ss(fi,0) # initial state = 0

- # essentially here we implement the combination of modulation and channel as a memoryless modulation (the memory induced by the channel is hidden in the innner FSM)

- mod = gr.chunks_to_symbols_sf(tot_constellation,dimensionality)

-

- # CHANNEL

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

- # RX

- (head,tail) = make_rx(fg,fo,fi,dimensionality,tot_constellation,K,interleaver,IT,Es,N0,trellis.TRELLIS_MIN_SUM)

- fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts

- dst = gr.check_lfsr_32k_s();

-

- fg.connect (src,src_head,s2fsmi,enc_out,inter,enc_in,mod)

- fg.connect (mod,(add,0))

- fg.connect (noise,(add,1))

- fg.connect (add,head)

- fg.connect (tail,fsmi2s,dst)

-

- fg.run()

-

- ntotal = dst.ntotal ()

- nright = dst.nright ()

- runlength = dst.runlength ()

- #print ntotal,nright,runlength

-

- return (ntotal,ntotal-nright)

-

-

-

-

-def main(args):

- nargs = len (args)

- if nargs == 3:

- fname_out=args[0]

- esn0_db=float(args[1])

- rep=int(args[2])

- else:

- sys.stderr.write ('usage: test_turbo_equalization.py fsm_name_out Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- Kb=64*16 # packet size in bits (multiple of 16)

- modulation = fsm_utils.pam4 # see fsm_utlis.py for available predefined modulations

- channel = fsm_utils.c_channel # see fsm_utlis.py for available predefined test channels

- fo=trellis.fsm(fname_out) # get the outer FSM specification from a file

- fi=trellis.fsm(len(modulation[1]),len(channel)) # generate the FSM automatically

- if fo.O() != fi.I():

- sys.stderr.write ('Incompatible cardinality between outer and inner FSM.\n')

- sys.exit (1)

- bitspersymbol = int(round(math.log(fo.I())/math.log(2))) # bits per FSM input symbol

- K=Kb/bitspersymbol # packet size in trellis steps

- print 'size = ',K

- interleaver=trellis.interleaver(K,666) # construct a random interleaver

- tot_channel = fsm_utils.make_isi_lookup(modulation,channel,True) # generate the lookup table (normalize energy to 1)

- dimensionality = tot_channel[0]

- tot_constellation = tot_channel[1]

- if len(tot_constellation)/dimensionality != fi.O():

- sys.stderr.write ('Incompatible FSM output cardinality and lookup table size.\n')

- sys.exit (1)

- N0=pow(10.0,-esn0_db/10.0); # noise variance

- IT = 3 # number of turbo iterations

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

-

- for i in range(rep):

- (s,e)=run_test(fo,fi,interleaver,Kb,bitspersymbol,K,dimensionality,tot_constellation,1,N0,IT,-long(666+i)) # run experiment with different seed to get different noise realizations

- print s

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%10==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import random

-import fsm_utils

-

-def make_rx(fg,fo,fi,dimensionality,tot_constellation,K,interleaver,IT,Es,N0,type):

- metrics_in = trellis.metrics_f(fi.O(),dimensionality,tot_constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for innner SISO

- scale = gr.multiply_const_ff(1.0/N0)

- gnd = gr.vector_source_f([0],True);

-

- inter=[]

- deinter=[]

- siso_in=[]

- siso_out=[]

-

- # generate all blocks

- for it in range(IT):

- inter.append( trellis.permutation(interleaver.K(),interleaver.INTER(),fi.I(),gr.sizeof_float) )

- siso_in.append( trellis.siso_f(fi,K,0,-1,True,False,type) )

- deinter.append( trellis.permutation(interleaver.K(),interleaver.DEINTER(),fi.I(),gr.sizeof_float) )

- if it < IT-1:

- siso_out.append( trellis.siso_f(fo,K,0,-1,False,True,type) )

- else:

- siso_out.append( trellis.viterbi_s(fo,K,0,-1) ) # no soft outputs needed

-

- # connect first stage

- fg.connect (gnd,inter[0])

- fg.connect (metrics_in,scale)

- fg.connect (scale,(siso_in[0],1))

-

- # connect the rest

- for it in range(IT):

- if it < IT-1:

- fg.connect (scale,(siso_in[it+1],1))

- fg.connect (siso_in[it],deinter[it],(siso_out[it],1))

- fg.connect (gnd,(siso_out[it],0))

- fg.connect (siso_out[it],inter[it+1])

- fg.connect (inter[it],(siso_in[it],0))

- else:

- fg.connect (siso_in[it],deinter[it],siso_out[it])

- fg.connect (inter[it],(siso_in[it],0))

-

- return (metrics_in,siso_out[IT-1])

-

-

-def run_test (fo,fi,interleaver,Kb,bitspersymbol,K,channel,modulation,dimensionality,tot_constellation,Es,N0,IT,seed):

- fg = gr.flow_graph ()

- L = len(channel)

-

- # TX

- # this for loop is TOO slow in python!!!

- packet = [0]*(K)

- random.seed(seed)

- for i in range(len(packet)):

- packet[i] = random.randint(0, 2**bitspersymbol - 1) # random symbols

- src = gr.vector_source_s(packet,False)

- enc_out = trellis.encoder_ss(fo,0) # initial state = 0

- inter = trellis.permutation(interleaver.K(),interleaver.INTER(),1,gr.sizeof_short)

- mod = gr.chunks_to_symbols_sf(modulation[1],modulation[0])

-

- # CHANNEL

- isi = gr.fir_filter_fff(1,channel)

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

- # RX

- (head,tail) = make_rx(fg,fo,fi,dimensionality,tot_constellation,K,interleaver,IT,Es,N0,trellis.TRELLIS_MIN_SUM)

- dst = gr.vector_sink_s();

-

- fg.connect (src,enc_out,inter,mod)

- fg.connect (mod,isi,(add,0))

- fg.connect (noise,(add,1))

- fg.connect (add,head)

- fg.connect (tail,dst)

-

- fg.run()

-

- data = dst.data()

- ntotal = len(data)

- nright=0

- for i in range(ntotal):

- if packet[i]==data[i]:

- nright=nright+1

- #else:

- #print "Error in ", i

-

- return (ntotal,ntotal-nright)

-

-

-

-

-def main(args):

- nargs = len (args)

- if nargs == 3:

- fname_out=args[0]

- esn0_db=float(args[1])

- rep=int(args[2])

- else:

- sys.stderr.write ('usage: test_turbo_equalization.py fsm_name_out Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- Kb=64*16 # packet size in bits (multiple of 16)

- modulation = fsm_utils.pam4 # see fsm_utlis.py for available predefined modulations

- channel = fsm_utils.c_channel # see fsm_utlis.py for available predefined test channels

- fo=trellis.fsm(fname_out) # get the outer FSM specification from a file

- fi=trellis.fsm(len(modulation[1]),len(channel)) # generate the FSM automatically

- if fo.O() != fi.I():

- sys.stderr.write ('Incompatible cardinality between outer and inner FSM.\n')

- sys.exit (1)

- bitspersymbol = int(round(math.log(fo.I())/math.log(2))) # bits per FSM input symbol

- K=Kb/bitspersymbol # packet size in trellis steps

- interleaver=trellis.interleaver(K,666) # construct a random interleaver

- tot_channel = fsm_utils.make_isi_lookup(modulation,channel,True) # generate the lookup table (normalize energy to 1)

- dimensionality = tot_channel[0]

- tot_constellation = tot_channel[1]

- if len(tot_constellation)/dimensionality != fi.O():

- sys.stderr.write ('Incompatible FSM output cardinality and lookup table size.\n')

- sys.exit (1)

- N0=pow(10.0,-esn0_db/10.0); # noise variance

- IT = 3 # number of turbo iterations

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

-

- for i in range(rep):

- (s,e)=run_test(fo,fi,interleaver,Kb,bitspersymbol,K,channel,modulation,dimensionality,tot_constellation,1,N0,IT,-long(666+i)) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%10==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import random

-import fsm_utils

-

-def make_rx(fg,fo,fi,dimensionality,tot_constellation,K,interleaver,IT,Es,N0,type):

- scale = gr.multiply_const_ff(math.sqrt(1.0/N0))

- gnd = gr.vector_source_f([0],True);

-

- inter=[]

- deinter=[]

- siso_in=[]

- siso_out=[]

-

- # generate all blocks

- for it in range(IT):

- inter.append( trellis.permutation(interleaver.K(),interleaver.INTER(),fi.I(),gr.sizeof_float) )

- siso_in.append( trellis.siso_combined_f(fi,K,0,-1,True,False,type,dimensionality,tot_constellation,trellis.TRELLIS_EUCLIDEAN) )

- deinter.append( trellis.permutation(interleaver.K(),interleaver.DEINTER(),fi.I(),gr.sizeof_float) )

- if it < IT-1:

- siso_out.append( trellis.siso_f(fo,K,0,-1,False,True,type) )

- else:

- siso_out.append( trellis.viterbi_s(fo,K,0,-1) ) # no soft outputs needed

-

- # connect first stage

- fg.connect (gnd,inter[0])

- fg.connect (scale,(siso_in[0],1))

-

- # connect the rest

- for it in range(IT):

- if it < IT-1:

- fg.connect (scale,(siso_in[it+1],1))

- fg.connect (siso_in[it],deinter[it],(siso_out[it],1))

- fg.connect (gnd,(siso_out[it],0))

- fg.connect (siso_out[it],inter[it+1])

- fg.connect (inter[it],(siso_in[it],0))

- else:

- fg.connect (siso_in[it],deinter[it],siso_out[it])

- fg.connect (inter[it],(siso_in[it],0))

-

- return (scale,siso_out[IT-1])

-

-

-def run_test (fo,fi,interleaver,Kb,bitspersymbol,K,channel,modulation,dimensionality,tot_constellation,Es,N0,IT,seed):

- fg = gr.flow_graph ()

- L = len(channel)

-

- # TX

- # this for loop is TOO slow in python!!!

- packet = [0]*(K)

- random.seed(seed)

- for i in range(len(packet)):

- packet[i] = random.randint(0, 2**bitspersymbol - 1) # random symbols

- src = gr.vector_source_s(packet,False)

- enc_out = trellis.encoder_ss(fo,0) # initial state = 0

- inter = trellis.permutation(interleaver.K(),interleaver.INTER(),1,gr.sizeof_short)

- mod = gr.chunks_to_symbols_sf(modulation[1],modulation[0])

-

- # CHANNEL

- isi = gr.fir_filter_fff(1,channel)

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

- # RX

- (head,tail) = make_rx(fg,fo,fi,dimensionality,tot_constellation,K,interleaver,IT,Es,N0,trellis.TRELLIS_MIN_SUM)

- dst = gr.vector_sink_s();

-

- fg.connect (src,enc_out,inter,mod)

- fg.connect (mod,isi,(add,0))

- fg.connect (noise,(add,1))

- fg.connect (add,head)

- fg.connect (tail,dst)

-

- fg.run()

-

- data = dst.data()

- ntotal = len(data)

- nright=0

- for i in range(ntotal):

- if packet[i]==data[i]:

- nright=nright+1

- #else:

- #print "Error in ", i

-

- return (ntotal,ntotal-nright)

-

-

-

-

-def main(args):

- nargs = len (args)

- if nargs == 3:

- fname_out=args[0]

- esn0_db=float(args[1])

- rep=int(args[2])

- else:

- sys.stderr.write ('usage: test_turbo_equalization.py fsm_name_out Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- Kb=64*16 # packet size in bits (multiple of 16)

- modulation = fsm_utils.pam4 # see fsm_utlis.py for available predefined modulations

- channel = fsm_utils.c_channel # see fsm_utlis.py for available predefined test channels

- fo=trellis.fsm(fname_out) # get the outer FSM specification from a file

- fi=trellis.fsm(len(modulation[1]),len(channel)) # generate the FSM automatically

- if fo.O() != fi.I():

- sys.stderr.write ('Incompatible cardinality between outer and inner FSM.\n')

- sys.exit (1)

- bitspersymbol = int(round(math.log(fo.I())/math.log(2))) # bits per FSM input symbol

- K=Kb/bitspersymbol # packet size in trellis steps

- interleaver=trellis.interleaver(K,666) # construct a random interleaver

- tot_channel = fsm_utils.make_isi_lookup(modulation,channel,True) # generate the lookup table (normalize energy to 1)

- dimensionality = tot_channel[0]

- N0=pow(10.0,-esn0_db/10.0); # noise variance

- tot_constellation =[0]*len(tot_channel[1])

- for i in range(len(tot_channel[1])):

- tot_constellation[i] = tot_channel[1][i] * math.sqrt(1.0/N0)

- if len(tot_constellation)/dimensionality != fi.O():

- sys.stderr.write ('Incompatible FSM output cardinality and lookup table size.\n')

- sys.exit (1)

- IT = 3 # number of turbo iterations

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

-

- for i in range(rep):

- (s,e)=run_test(fo,fi,interleaver,Kb,bitspersymbol,K,channel,modulation,dimensionality,tot_constellation,1,N0,IT,-long(666+i)) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%10==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import fsm_utils

-

-def run_test (f,Kb,bitspersymbol,K,dimensionality,tot_constellation,N0,seed):

- fg = gr.flow_graph ()

-

- # TX

- src = gr.lfsr_32k_source_s()

- src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts

- s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality

- enc = trellis.encoder_ss(f,0) # initial state = 0

- # essentially here we implement the combination of modulation and channel as a memoryless modulation (the memory induced by the channel is hidden in the FSM)

- mod = gr.chunks_to_symbols_sf(tot_constellation,dimensionality)

-

- # CHANNEL

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

- # RX

- metrics = trellis.metrics_f(f.O(),dimensionality,tot_constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi

- va = trellis.viterbi_s(f,K,0,-1) # Put -1 if the Initial/Final states are not set.

- fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts

- dst = gr.check_lfsr_32k_s();

-

- fg.connect (src,src_head,s2fsmi,enc,mod)

- fg.connect (mod,(add,0))

- fg.connect (noise,(add,1))

- fg.connect (add,metrics)

- fg.connect (metrics,va,fsmi2s,dst)

-

- fg.run()

-

- ntotal = dst.ntotal ()

- nright = dst.nright ()

- runlength = dst.runlength ()

- #print ntotal,nright,runlength

-

- return (ntotal,ntotal-nright)

-

-

-

-

-def main(args):

- nargs = len (args)

- if nargs == 2:

- esn0_db=float(args[0])

- rep=int(args[1])

- else:

- sys.stderr.write ('usage: test_viterbi_equalization.py Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- Kb=128*16 # packet size in bits (multiple of 16)

- modulation = fsm_utils.pam4 # see fsm_utlis.py for available predefined modulations

- channel = fsm_utils.c_channel # see fsm_utlis.py for available predefined test channels

- f=trellis.fsm(len(modulation[1]),len(channel)) # generate the FSM automatically

- bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol

- K=Kb/bitspersymbol # packet size in trellis steps

-

- tot_channel = fsm_utils.make_isi_lookup(modulation,channel,True) # generate the lookup table (normalize energy to 1)

- dimensionality = tot_channel[0]

- tot_constellation = tot_channel[1]

- N0=pow(10.0,-esn0_db/10.0); # noise variance

- if len(tot_constellation)/dimensionality != f.O():

- sys.stderr.write ('Incompatible FSM output cardinality and lookup table size.\n')

- sys.exit (1)

-

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

-

- for i in range(rep):

- (s,e)=run_test(f,Kb,bitspersymbol,K,dimensionality,tot_constellation,N0,-long(666+i)) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%100==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or bit) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])

-

-#!/usr/bin/env python

-

-from gnuradio import gr

-from gnuradio import audio

-from gnuradio import trellis

-from gnuradio import eng_notation

-import math

-import sys

-import random

-import fsm_utils

-

-def run_test (f,Kb,bitspersymbol,K,channel,modulation,dimensionality,tot_constellation,N0,seed):

- fg = gr.flow_graph ()

- L = len(channel)

-

- # TX

- # this for loop is TOO slow in python!!!

- packet = [0]*(K+2*L)

- random.seed(seed)

- for i in range(len(packet)):

- packet[i] = random.randint(0, 2**bitspersymbol - 1) # random symbols

- for i in range(L): # first/last L symbols set to 0

- packet[i] = 0

- packet[len(packet)-i-1] = 0

- src = gr.vector_source_s(packet,False)

- mod = gr.chunks_to_symbols_sf(modulation[1],modulation[0])

-

- # CHANNEL

- isi = gr.fir_filter_fff(1,channel)

- add = gr.add_ff()

- noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)

-

- # RX

- skip = gr.skiphead(gr.sizeof_float, L) # skip the first L samples since you know they are coming from the L zero symbols

- #metrics = trellis.metrics_f(f.O(),dimensionality,tot_constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi

- #va = trellis.viterbi_s(f,K+L,-1,0) # Put -1 if the Initial/Final states are not set.

- va = trellis.viterbi_combined_fs(f,K+L,0,0,dimensionality,tot_constellation,trellis.TRELLIS_EUCLIDEAN) # using viterbi_combined_fs instead of metrics_f/viterbi_s allows larger packet lengths because metrics_f is complaining for not being able to allocate large buffers. This is due to the large f.O() in this application...

- dst = gr.vector_sink_s()

-

- fg.connect (src,mod)

- fg.connect (mod,isi,(add,0))

- fg.connect (noise,(add,1))

- #fg.connect (add,metrics)

- #fg.connect (metrics,va,dst)

- fg.connect (add,skip,va,dst)

-

- fg.run()

-

- data = dst.data()

- ntotal = len(data) - L

- nright=0

- for i in range(ntotal):

- if packet[i+L]==data[i]:

- nright=nright+1

- #else:

- #print "Error in ", i

-

- return (ntotal,ntotal-nright)

-

-

-def main(args):

- nargs = len (args)

- if nargs == 2:

- esn0_db=float(args[0])

- rep=int(args[1])

- else:

- sys.stderr.write ('usage: test_viterbi_equalization1.py Es/No_db repetitions\n')

- sys.exit (1)

-

- # system parameters

- Kb=128*16 # packet size in bits (multiple of 16)

- modulation = fsm_utils.pam4 # see fsm_utlis.py for available predefined modulations

- channel = fsm_utils.c_channel # see fsm_utlis.py for available predefined test channels

- f=trellis.fsm(len(modulation[1]),len(channel)) # generate the FSM automatically

- bitspersymbol = int(round(math.log(f.I())/math.log(2))) # bits per FSM input symbol

- K=Kb/bitspersymbol # packet size in trellis steps

-

- tot_channel = fsm_utils.make_isi_lookup(modulation,channel,True) # generate the lookup table (normalize energy to 1)

- dimensionality = tot_channel[0]

- tot_constellation = tot_channel[1]

- N0=pow(10.0,-esn0_db/10.0); # noise variance

- if len(tot_constellation)/dimensionality != f.O():

- sys.stderr.write ('Incompatible FSM output cardinality and lookup table size.\n')

- sys.exit (1)

-

- tot_s=0 # total number of transmitted shorts

- terr_s=0 # total number of shorts in error

- terr_p=0 # total number of packets in error

-

- for i in range(rep):

- (s,e)=run_test(f,Kb,bitspersymbol,K,channel,modulation,dimensionality,tot_constellation,N0,-long(666+i)) # run experiment with different seed to get different noise realizations

- tot_s=tot_s+s

- terr_s=terr_s+e

- terr_p=terr_p+(terr_s!=0)

- if ((i+1)%100==0) : # display progress

- print i+1,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

- # estimate of the (short or symbol) error rate

- print rep,terr_p, '%.2e' % ((1.0*terr_p)/(i+1)),tot_s,terr_s, '%.2e' % ((1.0*terr_s)/tot_s)

-

-

-

-if __name__ == '__main__':

- main (sys.argv[1:])