-
Notifications
You must be signed in to change notification settings - Fork 0
/
bladeRF_transceiver.py
345 lines (283 loc) · 14.4 KB
/
bladeRF_transceiver.py
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
#!/usr/bin/env python2
##################################################
# GNU Radio Python Flow Graph
# Title: bladeRF_transceiver
# Author: Renzo Chan Rios
# Generated: Thu Mar 17 14:38:31 2016
##################################################
from gnuradio import analog
from gnuradio import blocks
from gnuradio import digital
from gnuradio import eng_notation
from gnuradio import filter
from gnuradio import gr
from gnuradio.eng_option import eng_option
from gnuradio.filter import firdes
from grc_gnuradio import blks2 as grc_blks2
from optparse import OptionParser
import cc1111
import math
import osmosdr
class bladeRF_transceiver(gr.top_block):
def __init__(self):
gr.top_block.__init__(self, "bladeRF_transceiver")
##################################################
# Variables
##################################################
self.symbole_rate = symbole_rate = 10e3
self.samp_rate = samp_rate = 1e6
self.rat_interop = rat_interop = 8
self.rat_decim = rat_decim = 5
self.firdes_transition_width = firdes_transition_width = 15000
self.firdes_decim = firdes_decim = 4
self.firdes_cuttoff = firdes_cuttoff = 21e3
self.tx_valve_value = tx_valve_value = False
self.tx_rf_gain = tx_rf_gain = 10
self.tx_bb_gain = tx_bb_gain = -20
self.samp_per_sym_source = samp_per_sym_source = ((samp_rate/2/firdes_decim)*rat_interop/rat_decim) / symbole_rate
self.samp_per_sym = samp_per_sym = int(samp_rate / symbole_rate)
self.rx_valve_value = rx_valve_value = False
self.rx_rf_gain = rx_rf_gain = 3
self.rx_bb_gain = rx_bb_gain = 20
self.preamble = preamble = '0101010101010101'
self.msg_source_msgq_in = msg_source_msgq_in = gr.msg_queue(2)
self.msg_sink_msgq_out = msg_sink_msgq_out = gr.msg_queue(2)
self.frequency_tx = frequency_tx = 450e6
self.frequency_shift = frequency_shift = 520000
self.frequency_rx = frequency_rx = 450.0e6
self.firdes_filter = firdes_filter = firdes.low_pass(1,samp_rate/2, firdes_cuttoff, firdes_transition_width)
self.bit_per_sym = bit_per_sym = 1
self.bandwith = bandwith = 6e6
self.access_code = access_code = '11010011100100011101001110010001'
##################################################
# Blocks
##################################################
self.xlating_fir_filter_1 = filter.freq_xlating_fir_filter_ccc(2, (1, ), frequency_shift, samp_rate)
self.xlating_fir_filter_0 = filter.freq_xlating_fir_filter_ccc(firdes_decim, (firdes_filter), 0, samp_rate/2)
self.tx_valve = grc_blks2.valve(item_size=gr.sizeof_gr_complex*1, open=bool(tx_valve_value))
self.throttle = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate/2,True)
self.single_pole_iir_filter_xx_0 = filter.single_pole_iir_filter_ff(0.05, 1)
self.rx_valve = grc_blks2.valve(item_size=gr.sizeof_gr_complex*1, open=bool(rx_valve_value))
self.rational_resampler = filter.rational_resampler_ccc(
interpolation=rat_interop,
decimation=rat_decim,
taps=None,
fractional_bw=None,
)
self.quadrature_demod = analog.quadrature_demod_cf(2)
self.probe_signal_2 = blocks.probe_signal_f()
self.probe_signal_1 = blocks.probe_signal_f()
self.osmosdr_source = osmosdr.source( args="numchan=" + str(1) + " " + "bladerf=0" )
self.osmosdr_source.set_sample_rate(samp_rate)
self.osmosdr_source.set_center_freq(frequency_rx-frequency_shift, 0)
self.osmosdr_source.set_freq_corr(0, 0)
self.osmosdr_source.set_dc_offset_mode(0, 0)
self.osmosdr_source.set_iq_balance_mode(2, 0)
self.osmosdr_source.set_gain_mode(False, 0)
self.osmosdr_source.set_gain(rx_rf_gain, 0)
self.osmosdr_source.set_if_gain(0, 0)
self.osmosdr_source.set_bb_gain(rx_bb_gain, 0)
self.osmosdr_source.set_antenna("", 0)
self.osmosdr_source.set_bandwidth(bandwith, 0)
self.osmosdr_sink = osmosdr.sink( args="numchan=" + str(1) + " " + "bladerf=0" )
self.osmosdr_sink.set_sample_rate(samp_rate)
self.osmosdr_sink.set_center_freq(frequency_tx, 0)
self.osmosdr_sink.set_freq_corr(0, 0)
self.osmosdr_sink.set_gain(tx_rf_gain, 0)
self.osmosdr_sink.set_if_gain(0, 0)
self.osmosdr_sink.set_bb_gain(tx_bb_gain, 0)
self.osmosdr_sink.set_antenna("", 0)
self.osmosdr_sink.set_bandwidth(bandwith, 0)
self.nlog10_ff = blocks.nlog10_ff(10, 1, 0)
self.gmsk_mod = digital.gmsk_mod(
samples_per_symbol=int(samp_per_sym),
bt=0.5,
verbose=False,
log=False,
)
self.correlate_access_code = digital.correlate_access_code_bb(access_code, 4)
self.clock_recovery = digital.clock_recovery_mm_ff(samp_per_sym_source*(1+0.0), 0.25*0.175*0.175, 0.5, 0.175, 0.005)
self.cc1111_packet_encoder = cc1111.cc1111_packet_mod_base(cc1111.cc1111_packet_encoder(
samples_per_symbol=samp_per_sym,
bits_per_symbol=bit_per_sym,
preamble=preamble,
access_code=access_code,
pad_for_usrp=True,
do_whitening=True,
add_crc=True
),
source_queue=msg_source_msgq_in
)
self.cc1111_packet_decoder = cc1111.cc1111_packet_decoder(msg_sink_msgq_out,True, True, False, True)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_char*1)
self.blocks_keep_one_in_n = blocks.keep_one_in_n(gr.sizeof_float*1, int(samp_rate / 30))
self.blocks_delay_0 = blocks.delay(gr.sizeof_gr_complex*1, 1000)
self.blocks_complex_to_mag_squared_0_0 = blocks.complex_to_mag_squared(1)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1)
self.binary_slicer = digital.binary_slicer_fb()
self.avg_mag_sqrd = analog.probe_avg_mag_sqrd_c(0, 1)
##################################################
# Connections
##################################################
self.connect((self.binary_slicer, 0), (self.correlate_access_code, 0))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.probe_signal_2, 0))
self.connect((self.blocks_complex_to_mag_squared_0_0, 0), (self.single_pole_iir_filter_xx_0, 0))
self.connect((self.blocks_delay_0, 0), (self.osmosdr_sink, 0))
self.connect((self.blocks_keep_one_in_n, 0), (self.nlog10_ff, 0))
self.connect((self.cc1111_packet_decoder, 0), (self.blocks_null_sink_0, 0))
self.connect((self.cc1111_packet_encoder, 0), (self.gmsk_mod, 0))
self.connect((self.clock_recovery, 0), (self.binary_slicer, 0))
self.connect((self.correlate_access_code, 0), (self.cc1111_packet_decoder, 0))
self.connect((self.gmsk_mod, 0), (self.tx_valve, 0))
self.connect((self.nlog10_ff, 0), (self.probe_signal_1, 0))
self.connect((self.osmosdr_source, 0), (self.rx_valve, 0))
self.connect((self.quadrature_demod, 0), (self.clock_recovery, 0))
self.connect((self.rational_resampler, 0), (self.quadrature_demod, 0))
self.connect((self.rx_valve, 0), (self.avg_mag_sqrd, 0))
self.connect((self.rx_valve, 0), (self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.rx_valve, 0), (self.blocks_complex_to_mag_squared_0_0, 0))
self.connect((self.rx_valve, 0), (self.xlating_fir_filter_1, 0))
self.connect((self.single_pole_iir_filter_xx_0, 0), (self.blocks_keep_one_in_n, 0))
self.connect((self.throttle, 0), (self.xlating_fir_filter_0, 0))
self.connect((self.tx_valve, 0), (self.blocks_delay_0, 0))
self.connect((self.xlating_fir_filter_0, 0), (self.rational_resampler, 0))
self.connect((self.xlating_fir_filter_1, 0), (self.throttle, 0))
def get_symbole_rate(self):
return self.symbole_rate
def set_symbole_rate(self, symbole_rate):
self.symbole_rate = symbole_rate
self.set_samp_per_sym(int(self.samp_rate / self.symbole_rate))
self.set_samp_per_sym_source(((self.samp_rate/2/self.firdes_decim)*self.rat_interop/self.rat_decim) / self.symbole_rate)
def get_samp_rate(self):
return self.samp_rate
def set_samp_rate(self, samp_rate):
self.samp_rate = samp_rate
self.set_firdes_filter(firdes.low_pass(1,self.samp_rate/2, self.firdes_cuttoff, self.firdes_transition_width))
self.set_samp_per_sym(int(self.samp_rate / self.symbole_rate))
self.set_samp_per_sym_source(((self.samp_rate/2/self.firdes_decim)*self.rat_interop/self.rat_decim) / self.symbole_rate)
self.blocks_keep_one_in_n.set_n(int(self.samp_rate / 30))
self.osmosdr_sink.set_sample_rate(self.samp_rate)
self.osmosdr_source.set_sample_rate(self.samp_rate)
self.throttle.set_sample_rate(self.samp_rate/2)
def get_rat_interop(self):
return self.rat_interop
def set_rat_interop(self, rat_interop):
self.rat_interop = rat_interop
self.set_samp_per_sym_source(((self.samp_rate/2/self.firdes_decim)*self.rat_interop/self.rat_decim) / self.symbole_rate)
def get_rat_decim(self):
return self.rat_decim
def set_rat_decim(self, rat_decim):
self.rat_decim = rat_decim
self.set_samp_per_sym_source(((self.samp_rate/2/self.firdes_decim)*self.rat_interop/self.rat_decim) / self.symbole_rate)
def get_firdes_transition_width(self):
return self.firdes_transition_width
def set_firdes_transition_width(self, firdes_transition_width):
self.firdes_transition_width = firdes_transition_width
self.set_firdes_filter(firdes.low_pass(1,self.samp_rate/2, self.firdes_cuttoff, self.firdes_transition_width))
def get_firdes_decim(self):
return self.firdes_decim
def set_firdes_decim(self, firdes_decim):
self.firdes_decim = firdes_decim
self.set_samp_per_sym_source(((self.samp_rate/2/self.firdes_decim)*self.rat_interop/self.rat_decim) / self.symbole_rate)
def get_firdes_cuttoff(self):
return self.firdes_cuttoff
def set_firdes_cuttoff(self, firdes_cuttoff):
self.firdes_cuttoff = firdes_cuttoff
self.set_firdes_filter(firdes.low_pass(1,self.samp_rate/2, self.firdes_cuttoff, self.firdes_transition_width))
def get_tx_valve_value(self):
return self.tx_valve_value
def set_tx_valve_value(self, tx_valve_value):
self.tx_valve_value = tx_valve_value
self.tx_valve.set_open(bool(self.tx_valve_value))
def get_tx_rf_gain(self):
return self.tx_rf_gain
def set_tx_rf_gain(self, tx_rf_gain):
self.tx_rf_gain = tx_rf_gain
self.osmosdr_sink.set_gain(self.tx_rf_gain, 0)
def get_tx_bb_gain(self):
return self.tx_bb_gain
def set_tx_bb_gain(self, tx_bb_gain):
self.tx_bb_gain = tx_bb_gain
self.osmosdr_sink.set_bb_gain(self.tx_bb_gain, 0)
def get_samp_per_sym_source(self):
return self.samp_per_sym_source
def set_samp_per_sym_source(self, samp_per_sym_source):
self.samp_per_sym_source = samp_per_sym_source
self.clock_recovery.set_omega(self.samp_per_sym_source*(1+0.0))
def get_samp_per_sym(self):
return self.samp_per_sym
def set_samp_per_sym(self, samp_per_sym):
self.samp_per_sym = samp_per_sym
def get_rx_valve_value(self):
return self.rx_valve_value
def set_rx_valve_value(self, rx_valve_value):
self.rx_valve_value = rx_valve_value
self.rx_valve.set_open(bool(self.rx_valve_value))
def get_rx_rf_gain(self):
return self.rx_rf_gain
def set_rx_rf_gain(self, rx_rf_gain):
self.rx_rf_gain = rx_rf_gain
self.osmosdr_source.set_gain(self.rx_rf_gain, 0)
def get_rx_bb_gain(self):
return self.rx_bb_gain
def set_rx_bb_gain(self, rx_bb_gain):
self.rx_bb_gain = rx_bb_gain
self.osmosdr_source.set_bb_gain(self.rx_bb_gain, 0)
def get_preamble(self):
return self.preamble
def set_preamble(self, preamble):
self.preamble = preamble
def get_msg_source_msgq_in(self):
return self.msg_source_msgq_in
def set_msg_source_msgq_in(self, msg_source_msgq_in):
self.msg_source_msgq_in = msg_source_msgq_in
def get_msg_sink_msgq_out(self):
return self.msg_sink_msgq_out
def set_msg_sink_msgq_out(self, msg_sink_msgq_out):
self.msg_sink_msgq_out = msg_sink_msgq_out
def get_frequency_tx(self):
return self.frequency_tx
def set_frequency_tx(self, frequency_tx):
self.frequency_tx = frequency_tx
self.osmosdr_sink.set_center_freq(self.frequency_tx, 0)
def get_frequency_shift(self):
return self.frequency_shift
def set_frequency_shift(self, frequency_shift):
self.frequency_shift = frequency_shift
self.osmosdr_source.set_center_freq(self.frequency_rx-self.frequency_shift, 0)
self.xlating_fir_filter_1.set_center_freq(self.frequency_shift)
def get_frequency_rx(self):
return self.frequency_rx
def set_frequency_rx(self, frequency_rx):
self.frequency_rx = frequency_rx
self.osmosdr_source.set_center_freq(self.frequency_rx-self.frequency_shift, 0)
def get_firdes_filter(self):
return self.firdes_filter
def set_firdes_filter(self, firdes_filter):
self.firdes_filter = firdes_filter
self.xlating_fir_filter_0.set_taps((self.firdes_filter))
def get_bit_per_sym(self):
return self.bit_per_sym
def set_bit_per_sym(self, bit_per_sym):
self.bit_per_sym = bit_per_sym
def get_bandwith(self):
return self.bandwith
def set_bandwith(self, bandwith):
self.bandwith = bandwith
self.osmosdr_sink.set_bandwidth(self.bandwith, 0)
self.osmosdr_source.set_bandwidth(self.bandwith, 0)
def get_access_code(self):
return self.access_code
def set_access_code(self, access_code):
self.access_code = access_code
if __name__ == '__main__':
parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
(options, args) = parser.parse_args()
tb = bladeRF_transceiver()
tb.start()
try:
raw_input('Press Enter to quit: ')
except EOFError:
pass
tb.stop()
tb.wait()