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
|
#!/usr/bin/env python
#
# Copyright 2011 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 random
from cmath import exp, pi, log
from gnuradio import gr, gr_unittest, blks2
from utils import mod_codes
import digital_swig
# import from local folder
import psk
import qam
tested_mod_codes = (mod_codes.NO_CODE, mod_codes.GRAY_CODE)
# A list of the constellations to test.
# Each constellation is given by a 3-tuple.
# First item is a function to generate the constellation
# Second item is a dictionary of arguments for function with lists of
# possible values.
# Third item is whether differential encoding should be tested.
# Fourth item is the name of the argument to constructor that specifices
# whether differential encoding is used.
def twod_constell():
"""
"""
points = ((1+0j), (0+1j),
(-1+0j), (0-1j))
rot_sym = 2
dim = 2
return digital_swig.constellation_calcdist(points, [], rot_sym, dim)
def threed_constell():
oned_points = ((1+0j), (0+1j), (-1+0j), (0-1j))
points = []
r4 = range(0, 4)
for ia in r4:
for ib in r4:
for ic in r4:
points += [oned_points[ia], oned_points[ib], oned_points[ic]]
rot_sym = 4
dim = 3
return digital_swig.constellation_calcdist(points, [], rot_sym, dim)
tested_constellation_info = (
(psk.psk_constellation,
{'m': (2, 4, 8, 16, 32, 64),
'mod_code': tested_mod_codes, },
True, None),
(digital_swig.constellation_bpsk, {}, True, None),
(digital_swig.constellation_qpsk, {}, False, None),
(digital_swig.constellation_dqpsk, {}, True, None),
(digital_swig.constellation_8psk, {}, False, None),
(twod_constell, {}, True, None),
(threed_constell, {}, True, None),
)
def tested_constellations():
"""
Generator to produce (constellation, differential) tuples for testing purposes.
"""
for constructor, poss_args, differential, diff_argname in tested_constellation_info:
if differential:
diff_poss = (True, False)
else:
diff_poss = (False,)
poss_args = [[argname, argvalues, 0] for argname, argvalues in poss_args.items()]
for current_diff in diff_poss:
# Add an index into args to keep track of current position in argvalues
while True:
current_args = dict([(argname, argvalues[argindex])
for argname, argvalues, argindex in poss_args])
if diff_argname is not None:
current_args[diff_argname] = current_diff
constellation = constructor(**current_args)
yield (constellation, current_diff)
for this_poss_arg in poss_args:
argname, argvalues, argindex = this_poss_arg
if argindex < len(argvalues) - 1:
this_poss_arg[2] += 1
break
else:
this_poss_arg[2] = 0
if sum([argindex for argname, argvalues, argindex in poss_args]) == 0:
break
class test_constellation (gr_unittest.TestCase):
src_length = 256
def setUp(self):
# Generate a list of random bits.
self.src_data = tuple([random.randint(0,1) for i in range(0, self.src_length)])
def tearDown(self):
pass
def test_hard_decision(self):
for constellation, differential in tested_constellations():
if differential:
rs = constellation.rotational_symmetry()
rotations = [exp(i*2*pi*(0+1j)/rs) for i in range(0, rs)]
else:
rotations = [None]
for rotation in rotations:
src = gr.vector_source_b(self.src_data)
content = mod_demod(constellation, differential, rotation)
dst = gr.vector_sink_b()
self.tb = gr.top_block()
self.tb.connect(src, content, dst)
self.tb.run()
data = dst.data()
# Don't worry about cut off data for now.
first = constellation.bits_per_symbol()
self.assertEqual (self.src_data[first:len(data)], data[first:])
class mod_demod(gr.hier_block2):
def __init__(self, constellation, differential, rotation):
if constellation.arity() > 256:
# If this becomes limiting some of the blocks should be generalised so
# that they can work with shorts and ints as well as chars.
raise ValueError("Constellation cannot contain more than 256 points.")
gr.hier_block2.__init__(self, "mod_demod",
gr.io_signature(1, 1, gr.sizeof_char), # Input signature
gr.io_signature(1, 1, gr.sizeof_char)) # Output signature
arity = constellation.arity()
# TX
self.constellation = constellation
self.differential = differential
self.blocks = [self]
# We expect a stream of unpacked bits.
# First step is to pack them.
self.blocks.append(
gr.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST))
# Second step we unpack them such that we have k bits in each byte where
# each constellation symbol hold k bits.
self.blocks.append(
gr.packed_to_unpacked_bb(self.constellation.bits_per_symbol(),
gr.GR_MSB_FIRST))
# Apply any pre-differential coding
# Gray-coding is done here if we're also using differential coding.
if self.constellation.apply_pre_diff_code():
self.blocks.append(gr.map_bb(self.constellation.pre_diff_code()))
# Differential encoding.
if self.differential:
self.blocks.append(gr.diff_encoder_bb(arity))
# Convert to constellation symbols.
self.blocks.append(gr.chunks_to_symbols_bc(self.constellation.points(),
self.constellation.dimensionality()))
# CHANNEL
# Channel just consists of a rotation to check differential coding.
if rotation is not None:
self.blocks.append(gr.multiply_const_cc(rotation))
# RX
# Convert the constellation symbols back to binary values.
self.blocks.append(digital_swig.constellation_decoder_cb(self.constellation.base()))
# Differential decoding.
if self.differential:
self.blocks.append(gr.diff_decoder_bb(arity))
# Decode any pre-differential coding.
if self.constellation.apply_pre_diff_code():
self.blocks.append(gr.map_bb(
mod_codes.invert_code(self.constellation.pre_diff_code())))
# unpack the k bit vector into a stream of bits
self.blocks.append(gr.unpack_k_bits_bb(
self.constellation.bits_per_symbol()))
# connect to block output
check_index = len(self.blocks)
self.blocks = self.blocks[:check_index]
self.blocks.append(self)
self.connect(*self.blocks)
if __name__ == '__main__':
gr_unittest.run(test_constellation, "test_constellation.xml")
|
