def __init__(self, infile='0', outfile='0'):
gr.top_block.__init__(self, "Convert Metadata File")
##################################################
# Parameters
##################################################
self.infile = infile
self.outfile = outfile
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 40000
##################################################
# Blocks
##################################################
self.blocks_file_sink_1 = blocks.file_sink(gr.sizeof_gr_complex*1, outfile, False)
self.blocks_file_sink_1.set_unbuffered(False)
self.blocks_file_meta_source_0 = blocks.file_meta_source(infile, False, False, '')
##################################################
# Connections
##################################################
self.connect((self.blocks_file_meta_source_0, 0), (self.blocks_file_sink_1, 0))
def __init__(self):
gr.top_block.__init__(self, "Meta To Data")
##################################################
# Variables
##################################################
meta_file = "./Data/meta.raw"
data_file = "./Data/data.raw"
header_file = "./Data/header.txt"
##################################################
# Blocks
##################################################
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex * 1,
data_file, False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_file_meta_source_0 = blocks.file_meta_source(
meta_file, True, False, '')
##################################################
# Connections
##################################################
self.connect((self.blocks_file_meta_source_0, 0),
(self.blocks_file_sink_0, 0))
##################################################
# Get header info
##################################################
print "##################################################"
print "# Header Info #"
print "##################################################"
handle = open(meta_file, "rb")
hdr_start = handle.tell()
header_str = handle.read(parse_file_metadata.HEADER_LENGTH)
header = pmt.deserialize_str(header_str)
info = parse_file_metadata.parse_header(header, True)
if (info["extra_len"] > 0):
extra_str = handle.read(info["extra_len"])
extra = pmt.deserialize_str(extra_str)
extra_info = parse_file_metadata.parse_extra_dict(extra, info, True)
handle.close()
header = open(header_file, "wb")
rx_rate = extra_info['rx_rate']
rx_freq = pmt.to_python(extra_info['rx_freq'])
rx_time = extra_info['rx_time']
header.write("%.00f\n" % rx_rate)
header.write("%.00f\n" % rx_freq)
header.write("%.22f\n" % rx_time)
header.close()
print
def __init__(self):
gr.top_block.__init__(self, "Debug")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.tagtools_gapfiller_0 = tagtools.gapfiller()
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_gr_complex*1)
self.blocks_file_meta_source_0 = blocks.file_meta_source("tmp_detached", False, True, "tmp_detached.hdr")
##################################################
# Connections
##################################################
self.connect((self.blocks_file_meta_source_0, 0), (self.tagtools_gapfiller_0, 0))
self.connect((self.tagtools_gapfiller_0, 0), (self.blocks_null_sink_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Debug")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.tagtools_gapfiller_0 = tagtools.gapfiller()
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_gr_complex * 1)
self.blocks_file_meta_source_0 = blocks.file_meta_source(
"tmp_detached", False, True, "tmp_detached.hdr")
##################################################
# Connections
##################################################
self.connect((self.blocks_file_meta_source_0, 0),
(self.tagtools_gapfiller_0, 0))
self.connect((self.tagtools_gapfiller_0, 0),
(self.blocks_null_sink_0, 0))
def test_001(self):
N = 1000
outfile = "test_out.dat"
detached = False
samp_rate = 200000
key = pmt.intern("samp_rate")
val = pmt.from_double(samp_rate)
extras = pmt.make_dict()
extras = pmt.dict_add(extras, key, val)
data = sig_source_c(samp_rate, 1000, 1, N)
src = blocks.vector_source_c(data)
fsnk = blocks.file_meta_sink(gr.sizeof_gr_complex, outfile,
samp_rate, 1,
blocks.GR_FILE_FLOAT, True,
1000000, extras, detached)
fsnk.set_unbuffered(True)
self.tb.connect(src, fsnk)
self.tb.run()
fsnk.close()
handle = open(outfile, "rb")
header_str = handle.read(blocks.parse_file_metadata.HEADER_LENGTH)
if(len(header_str) == 0):
self.assertFalse()
try:
header = pmt.deserialize_str(header_str)
except RuntimeError:
self.assertFalse()
info = blocks.parse_header(header, False)
extra_str = handle.read(info["extra_len"])
self.assertEqual(len(extra_str) > 0, True)
handle.close()
try:
extra = pmt.deserialize_str(extra_str)
except RuntimeError:
self.assertFalse()
extra_info = blocks.parse_extra_dict(extra, info, False)
self.assertEqual(info['rx_rate'], samp_rate)
self.assertEqual(pmt.to_double(extra_info['samp_rate']), samp_rate)
# Test file metadata source
src.rewind()
fsrc = blocks.file_meta_source(outfile, False)
vsnk = blocks.vector_sink_c()
tsnk = blocks.tag_debug(gr.sizeof_gr_complex, "QA")
ssnk = blocks.vector_sink_c()
self.tb.disconnect(src, fsnk)
self.tb.connect(fsrc, vsnk)
self.tb.connect(fsrc, tsnk)
self.tb.connect(src, ssnk)
self.tb.run()
fsrc.close()
# Test to make sure tags with 'samp_rate' and 'rx_rate' keys
# were generated and received correctly.
tags = tsnk.current_tags()
for t in tags:
if(pmt.eq(t.key, pmt.intern("samp_rate"))):
self.assertEqual(pmt.to_double(t.value), samp_rate)
elif(pmt.eq(t.key, pmt.intern("rx_rate"))):
self.assertEqual(pmt.to_double(t.value), samp_rate)
# Test that the data portion was extracted and received correctly.
self.assertComplexTuplesAlmostEqual(vsnk.data(), ssnk.data(), 5)
os.remove(outfile)
def __init__(self):
gr.top_block.__init__(self, "Trial5 Record Fm Radio Playback")
Qt.QWidget.__init__(self)
self.setWindowTitle("Trial5 Record Fm Radio Playback")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio",
"Trial5_record_fm_radio_playback")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 250e3
self.gain = gain = 40
self.freq = freq = 92.7e6
self.deviation = deviation = 30e3 * 0 + 5e3
self.audio_rate = audio_rate = int(48e3)
##################################################
# Blocks
##################################################
self._samp_rate_tool_bar = Qt.QToolBar(self)
self._samp_rate_tool_bar.addWidget(Qt.QLabel('Sample Rate' + ": "))
self._samp_rate_line_edit = Qt.QLineEdit(str(self.samp_rate))
self._samp_rate_tool_bar.addWidget(self._samp_rate_line_edit)
self._samp_rate_line_edit.returnPressed.connect(
lambda: self.set_samp_rate(
eng_notation.str_to_num(
str(self._samp_rate_line_edit.text().toAscii()))))
self.top_layout.addWidget(self._samp_rate_tool_bar)
self.rational_resampler_xxx_0 = filter.rational_resampler_ccc(
interpolation=audio_rate,
decimation=int(samp_rate),
taps=None,
fractional_bw=None,
)
self.qtgui_time_sink_x_0 = qtgui.time_sink_c(
1024, #size
samp_rate, #samp_rate
"", #name
1 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0.set_y_label('Amplitude', "")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.0, 0,
0, "")
self.qtgui_time_sink_x_0.enable_autoscale(False)
self.qtgui_time_sink_x_0.enable_grid(False)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_time_sink_x_0.disable_legend()
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "blue"
]
styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(2):
if len(labels[i]) == 0:
if (i % 2 == 0):
self.qtgui_time_sink_x_0.set_line_label(
i, "Re{{Data {0}}}".format(i / 2))
else:
self.qtgui_time_sink_x_0.set_line_label(
i, "Im{{Data {0}}}".format(i / 2))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(
self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_time_sink_x_0_win)
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c(
1024, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"", #name
1 #number of inputs
)
self.qtgui_freq_sink_x_0.set_update_time(0.10)
self.qtgui_freq_sink_x_0.set_y_axis(-140, 10)
self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB')
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0,
"")
self.qtgui_freq_sink_x_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0.enable_grid(False)
self.qtgui_freq_sink_x_0.set_fft_average(1.0)
self.qtgui_freq_sink_x_0.enable_axis_labels(True)
self.qtgui_freq_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_freq_sink_x_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_freq_sink_x_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "dark blue"
]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(
self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_freq_sink_x_0_win)
self.low_pass_filter_0 = filter.fir_filter_fff(
1,
firdes.low_pass(1, audio_rate, 3.5e3, 0.5e3, firdes.WIN_HAMMING,
6.76))
self._gain_range = Range(0, 90, 1, 40, 200)
self._gain_win = RangeWidget(self._gain_range, self.set_gain, 'Gain',
"counter_slider", float)
self.top_layout.addWidget(self._gain_win)
self._freq_range = Range(90e6, 110e6, 50, 92.7e6, 200)
self._freq_win = RangeWidget(self._freq_range, self.set_freq,
'Frequency', "counter_slider", float)
self.top_layout.addWidget(self._freq_win)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1,
samp_rate, True)
self.blocks_float_to_complex_0 = blocks.float_to_complex(1)
# Zyg
# epochTimeStr = str(int(time.time()))
outFileName = 'Trial5_record_fm_radio.out'
# 'Trial1_SinewaveSrc_Mod_'+epochTimeStr+'.out'
outFilePath = os.path.join(curFileDir, outFileName)
self.blocks_file_meta_source_0 = blocks.file_meta_source(
outFilePath, True, False, '')
self.audio_sink_0 = audio.sink(audio_rate, '', True)
self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf(
(audio_rate / (2 * math.pi * deviation)) * 0 +
((2 * math.pi * deviation) / audio_rate))
self.analog_pwr_squelch_xx_0 = analog.pwr_squelch_cc(
-90, 1e-3, 0, False)
##################################################
# Connections
##################################################
self.connect((self.analog_pwr_squelch_xx_0, 0),
(self.analog_quadrature_demod_cf_0, 0))
self.connect((self.analog_pwr_squelch_xx_0, 0),
(self.qtgui_freq_sink_x_0, 0))
self.connect((self.analog_quadrature_demod_cf_0, 0),
(self.blocks_float_to_complex_0, 0))
self.connect((self.analog_quadrature_demod_cf_0, 0),
(self.low_pass_filter_0, 0))
self.connect((self.blocks_file_meta_source_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.blocks_float_to_complex_0, 0),
(self.qtgui_time_sink_x_0, 0))
self.connect((self.blocks_throttle_0, 0),
(self.rational_resampler_xxx_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.audio_sink_0, 0))
self.connect((self.low_pass_filter_0, 0),
(self.blocks_float_to_complex_0, 1))
self.connect((self.rational_resampler_xxx_0, 0),
(self.analog_pwr_squelch_xx_0, 0))
def test_001(self):
N = 1000
outfile = "test_out.dat"
detached = False
samp_rate = 200000
key = pmt.intern("samp_rate")
val = pmt.from_double(samp_rate)
extras = pmt.make_dict()
extras = pmt.dict_add(extras, key, val)
extras_str = pmt.serialize_str(extras)
data = sig_source_c(samp_rate, 1000, 1, N)
src = blocks.vector_source_c(data)
fsnk = blocks.file_meta_sink(gr.sizeof_gr_complex, outfile,
samp_rate, 1,
blocks.GR_FILE_FLOAT, True,
1000000, extras_str, detached)
fsnk.set_unbuffered(True)
self.tb.connect(src, fsnk)
self.tb.run()
fsnk.close()
handle = open(outfile, "rb")
header_str = handle.read(parse_file_metadata.HEADER_LENGTH)
if(len(header_str) == 0):
self.assertFalse()
try:
header = pmt.deserialize_str(header_str)
except RuntimeError:
self.assertFalse()
info = parse_file_metadata.parse_header(header, False)
extra_str = handle.read(info["extra_len"])
self.assertEqual(len(extra_str) > 0, True)
handle.close()
try:
extra = pmt.deserialize_str(extra_str)
except RuntimeError:
self.assertFalse()
extra_info = parse_file_metadata.parse_extra_dict(extra, info, False)
self.assertEqual(info['rx_rate'], samp_rate)
self.assertEqual(pmt.to_double(extra_info['samp_rate']), samp_rate)
# Test file metadata source
src.rewind()
fsrc = blocks.file_meta_source(outfile, False)
vsnk = blocks.vector_sink_c()
tsnk = blocks.tag_debug(gr.sizeof_gr_complex, "QA")
ssnk = blocks.vector_sink_c()
self.tb.disconnect(src, fsnk)
self.tb.connect(fsrc, vsnk)
self.tb.connect(fsrc, tsnk)
self.tb.connect(src, ssnk)
self.tb.run()
fsrc.close()
# Test to make sure tags with 'samp_rate' and 'rx_rate' keys
# were generated and received correctly.
tags = tsnk.current_tags()
for t in tags:
if(pmt.eq(t.key, pmt.intern("samp_rate"))):
self.assertEqual(pmt.to_double(t.value), samp_rate)
elif(pmt.eq(t.key, pmt.intern("rx_rate"))):
self.assertEqual(pmt.to_double(t.value), samp_rate)
# Test that the data portion was extracted and received correctly.
self.assertComplexTuplesAlmostEqual(vsnk.data(), ssnk.data(), 5)
os.remove(outfile)
def __init__(self, options):
grc_wxgui.top_block_gui.__init__(self, title="DSSDR")
self.initialized = False
self.stopped = False
self.options = copy.copy(options)
self._constellation = digital.constellation_bpsk()
self._excess_bw = options.excess_bw
self._phase_bw = options.phase_bw
self._freq_bw = options.freq_bw
self._timing_bw = options.timing_bw
self._if_freq = options.if_freq
self._timing_max_dev= 1.5
self._demod_class = digital.bpsk_demod # the demodulator_class we're using
self._chbw_factor = options.chbw_factor # channel filter bandwidth factor
self._samples_per_second = 2e6
self._nav_samples_per_second = 16e6
self._down_decim = 1
self._down_samples_per_second = self._scope_sample_rate = self._samples_per_second/self._down_decim
self._up_samples_per_second = 1e6
self._asm_threshold = 0
self._access_code = None
self._tm_packet_id = 4
self._timestamp_id = 5
self._down_bitrate = options.bitrate
self._up_bitrate = options.up_bitrate
self._up_samples_per_symbol = self._up_samples_per_second/self._up_bitrate
self._samples_per_symbol = self._samples_per_second/self._down_decim/self._down_bitrate
self._down_sub_freq = options.down_sub_freq
self._up_sub_freq = 25e3
self._tm_len = 8920
self._up_tm_len = 8920
self._coding_method = options.coding_method
self._up_coding_method = 'None'
self._up_subcarrier = 'Square'
self._rs_i = 1
self._ccsds_channel = 38
self._uhd_carrier_offset = 10e3
self._turn_div = 749
self._turn_mult = 880
self._modulation_index = 'pi/3'
self._up_modulation_index = 1.047
self._max_carrier_offset = 0.1
self._dssdr_mixer_freq = options.rf_freq
self._up_coding_rate = '1'
self._down_coding_rate = '1'
self._down_conv_en = "False"
self._down_randomizer_en = options.down_randomizer_en
self._down_manchester_en = options.down_manchester_en
self._up_conv_en = "False"
self._up_idle_sequence = "\\x55"
self._down_default_gain = 64
self._up_default_gain = 44
self._up_en = True
if self._access_code is None:
self._access_code = packet_utils.default_access_code
#Construct the lookup table for parameter-setting functions
self.param_setters = {
"DSSDR_CHANNEL": self.setChannel,
"DSSDR_LO_FREQ": self.setLOFreq,
"DSSDR_REF_FREQ": self.setRefFreq,
"DSSDR_TURN_MULT": self.setTurnMult,
"DSSDR_TURN_DIV": self.setTurnDiv,
"DSSDR_UP_GAIN": self.setUpGain,
"DSSDR_DOWN_GAIN": self.setDownGain,
"DSSDR_UP_BITRATE": self.setUpBitrate,
"DSSDR_DOWN_BITRATE": self.setDownBitrate,
"DSSDR_DOWN_SAMPLE_RATE": self.setSampRate,
"DSSDR_UP_SUB_FREQ": self.setUpSubFreq,
"DSSDR_DOWN_SUB_FREQ": self.setDownSubFreq,
"DSSDR_DOPPLER_REPORT": self.dopplerReport,
"DSSDR_PN_RANGE": self.rangePN,
"DSSDR_SEQUENTIAL_RANGE": self.rangeSequential,
"DSSDR_DOWN_CODING_METHOD": self.setDownCodingMethod,
"DSSDR_UP_CODING_METHOD": self.setUpCodingMethod,
"DSSDR_DOWN_TM_LEN": self.setTMLen,
"DSSDR_UP_TM_LEN": self.setUpTMLen,
"DSSDR_DOWN_MOD_IDX": self.setDownModulationIndex,
"DSSDR_UP_MOD_IDX": self.setUpModulationIndex,
"DSSDR_DOWN_CONV_EN": self.setDownConvEn,
"DSSDR_UP_CONV_EN": self.setUpConvEn,
"DSSDR_ASM_TOL": self.setASMThreshold,
"DSSDR_UP_SWEEP": self.freqSweep,
"DSSDR_UP_IDLE": self.setUpIdleSequence,
"DSSDR_UP_EN": self.setUpEn,
"DSSDR_SYNC_TIME": self.syncSDRTime,
"DSSDR_UP_SWEEP": self.freqSweep,
"DSSDR_DOWN_ACQUIRE": self.acquireCarrier,
"DSSDR_INPUT_SELECT": self.setPanelSelect,
"DSSDR_REF_SELECT": self.setRefSelect,
"DSSDR_PPS_SELECT": self.setPPSSelect
}
#TODO:Add status fields for things like DSSDR_REF_LOCK
self._dssdr_channels = {
3: [7149597994, 8400061729],
4: [7150753857, 8401419752],
5: [7151909723, 8402777779],
6: [7153065586, 8404135802],
7: [7154221449, 8405493825],
8: [7155377316, 8406851853],
9: [7156533179, 8408209877],
10: [7157689045, 8409567903],
11: [7158844908, 8410925927],
12: [7160000771, 8412283950],
13: [7161156637, 8413641977],
14: [7162312500, 8415000000],
15: [7163468363, 8416358023],
16: [7164624229, 8417716050],
17: [7165780092, 8419074073],
18: [7166935955, 8420432097],
19: [7168091821, 8421790123],
20: [7169247684, 8423148147],
21: [7170403551, 8424506175],
22: [7171559414, 8425864198],
23: [7172715277, 8427222221],
24: [7173871143, 8428580248],
25: [7175027006, 8429938271],
26: [7176182869, 8431296295],
27: [7177338735, 8432654321],
28: [7178494598, 8434012345],
29: [7179650464, 8435370372],
30: [7180806327, 8436728395],
31: [7181962190, 8438086418],
32: [7183118057, 8439444446],
33: [7184273920, 8440802469],
34: [7185429783, 8442160493],
35: [7186585649, 8443518520],
36: [7187741512, 8444876543],
37: [7188897378, 8446234570],
38: [7190000000, 8450000000],
}
#FLOWGRAPH STUFF
if options.test == True:
self.u = blks2.tcp_source(
itemsize=gr.sizeof_gr_complex*1,
addr="",
port=12905,
server=True
)
elif options.fromfile == True:
self.u2 = blocks.file_meta_source("iq_in.dat")
self.u = blocks.throttle(gr.sizeof_gr_complex*1, self._samples_per_second)
elif options.frombitlog == True:
self.u3 = blocks.file_source(gr.sizeof_char, "bitstream_recording.in", True)
self.u2 = blocks.uchar_to_float()
self.u1 = blocks.throttle(gr.sizeof_float*1, self._down_bitrate)
self.u = blocks.add_const_ff(-0.5)
else:
self.u = uhd.usrp_source(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
self.u.set_clock_source("external")
self.u.set_time_source("external")
self.u.set_samp_rate(self._samples_per_second)
self.u.set_antenna("RX2")
self.u.set_gain(self._down_default_gain)
self.frontend = dfi.dssdrFrontendInterface(self.u)
if options.debug_pps == True:
self.debug_pps = blocks.tag_debug(gr.sizeof_gr_complex, "debug-pps", "rx_time")
if options.tofile == True:
self.u_tx = blocks.file_meta_sink(gr.sizeof_gr_complex, "iq_out.dat", self._up_samples_per_second)
elif options.tonull == True:
self.u_tx = blocks.null_sink(gr.sizeof_gr_complex)
else:
self.u_tx = uhd.usrp_sink(device_addr=options.args, stream_args=uhd.stream_args('fc32'))
self.u_tx.set_clock_source("external")
self.u_tx.set_time_source("external")
self.u_tx.set_samp_rate(self._up_samples_per_second)
self.u_tx.set_antenna("TX/RX")
self.u_tx.set_gain(self._up_default_gain)
#GUI STUFF
if options.graphics == True:
self.nb0 = wx.Notebook(self.GetWin(), style=wx.NB_TOP)
self.nb0.AddPage(grc_wxgui.Panel(self.nb0), "RX")
self.nb0.AddPage(grc_wxgui.Panel(self.nb0), "TX")
self.nb0.AddPage(grc_wxgui.Panel(self.nb0), "Nav")
self.Add(self.nb0)
self.constellation_scope = scopesink2.scope_sink_c(
self.nb0.GetPage(0).GetWin(),
title="Scope Plot",
sample_rate=self._scope_sample_rate,
v_scale=0,
v_offset=0,
t_scale=0,
ac_couple=False,
xy_mode=True,
num_inputs=1,
trig_mode=wxgui.TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.nb0.GetPage(0).Add(self.constellation_scope.win)
#self.constellation_scope.win.set_marker('plus')
self._scope_is_fft = False
self.time_scope = scopesink2.scope_sink_f(
self.nb0.GetPage(0).GetWin(),
title="Scope Plot",
sample_rate=self._scope_sample_rate,
v_scale=0,
v_offset=0,
t_scale=.005,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=wxgui.TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.nb0.GetPage(0).Add(self.time_scope.win)
self.nb0.GetPage(0).GetWin()._box.Hide(self.time_scope.win)
self.fft_scope = fftsink2.fft_sink_c(
self.nb0.GetPage(0).GetWin(),
baseband_freq=0,
y_per_div=10,
y_divs=10,
ref_level=0,
ref_scale=2.0,
sample_rate=self._scope_sample_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
self.nb0.GetPage(0).Add(self.fft_scope.win)
self.nb0.GetPage(0).GetWin()._box.Hide(self.fft_scope.win)
self.row1_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.recording_onoff_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='Off',
callback=self.setRecording,
label="IQ Recording",
choices=['Off','On'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.front_panel_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='RF',
callback=self.setPanelSelect,
label="Input Select",
choices=['RF','IF'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.ref_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='Internal',
callback=self.setRefSelect,
label="Ref Select",
choices=['Internal','External'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.pps_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='Internal',
callback=self.setPPSSelect,
label="PPS Select",
choices=['Internal','External'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.sync_button = forms.button(
parent=self.nb0.GetPage(0).GetWin(),
value='Sync to PPS',
callback=self.syncSDRTime,
choices=['Sync to PPS'],
style=wx.RA_HORIZONTAL,
)
self.ref_locked_text = forms.static_text(
parent=self.nb0.GetPage(0).GetWin(),
value="",
callback=self.setRefLocked,
label="",
converter=forms.str_converter(),
)
self.row1_sizer.Add(self.recording_onoff_chooser, flag=wx.ALIGN_CENTER)
self.row1_sizer.Add(self.front_panel_chooser, flag=wx.ALIGN_CENTER)
self.row1_sizer.Add(self.ref_chooser, flag=wx.ALIGN_CENTER)
self.row1_sizer.Add(self.pps_chooser, flag=wx.ALIGN_CENTER)
self.row1_sizer.Add(self.sync_button, flag=wx.ALIGN_CENTER)
self.row1_sizer.Add(self.ref_locked_text, flag=wx.ALIGN_CENTER)
self.nb0.GetPage(0).Add(self.row1_sizer)
self.complex_scope_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='Constellation',
callback=self.setComplexScopeStyle,
label="Complex Scope",
choices=['Constellation','FFT'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(0).Add(self.complex_scope_chooser)
self.scope_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value='USRP',
callback=self.setScopePoint,
label="Scope Probe Point",
choices=['USRP','Carrier Tracking','Sub-Carrier Costas','Sub-Carrier Sync','Data Sync'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(0).Add(self.scope_chooser)
self._bitrate_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._down_bitrate,
callback=self.setDownBitrate,
label="Symbol Rate",
converter=forms.float_converter(),
)
self.nb0.GetPage(0).Add(self._bitrate_text_box)
self._samprate_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._samples_per_second,
callback=self.setSampRate,
label="Sampling Rate",
converter=forms.float_converter(),
)
self.nb0.GetPage(0).Add(self._samprate_text_box)
self._subcfreq_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._down_sub_freq,
callback=self.setDownSubFreq,
label="Downlink Subcarrier Frequency",
converter=forms.float_converter(),
)
self.nb0.GetPage(0).Add(self._subcfreq_text_box)
self._mod_index_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value=self._modulation_index,
callback=self.setDownModulationIndex,
label="Modulation Index",
choices=['pi/2', 'pi/3'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(0).Add(self._mod_index_chooser)
self._pktlen_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._tm_len,
callback=self.setTMLen,
label="Downlink Packet Length (bits)",
converter=forms.float_converter(),
)
self.nb0.GetPage(0).Add(self._pktlen_text_box)
self._coding_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value=self._coding_method,
callback=self.setDownCodingMethod,
label="Coding",
choices=['None', 'RS', 'Turbo 1/2', 'Turbo 1/3', 'Turbo 1/4', 'Turbo 1/6'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(0).Add(self._coding_chooser)
self._down_conv_check_box = forms.check_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._down_conv_en,
callback=self.setDownConvEn,
label="Convolutional Decode",
true="True",
false="False",
)
self.nb0.GetPage(0).Add(self._down_conv_check_box)
self._down_randomizer_check_box = forms.check_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._down_randomizer_en,
callback=self.setDownRandomizerEn,
label="De-randomizer",
true=True,
false=False,
)
self.nb0.GetPage(0).Add(self._down_randomizer_check_box)
self._down_manchester_check_box = forms.check_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._down_manchester_en,
callback=self.setDownManchesterEn,
label="Manchester Decode",
true=True,
false=False,
)
self.nb0.GetPage(0).Add(self._down_manchester_check_box)
self._pktlen_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._asm_threshold,
callback=self.setASMThreshold,
label="ASM Error Tolerance (bits)",
converter=forms.float_converter(),
)
self.nb0.GetPage(0).Add(self._pktlen_text_box)
self._coding_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(0).GetWin(),
value=self._rs_i,
callback=self.setRSI,
label="Reed-Solomon Interleaving Depth",
choices=[1,5],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(0).Add(self._coding_chooser)
self._ccsds_chan_text_box = forms.text_box(
parent=self.nb0.GetPage(0).GetWin(),
value=self._ccsds_channel,
callback=self.setChannel,
label="CCSDS Channel",
converter=forms.int_converter(),
)
self.nb0.GetPage(0).Add(self._ccsds_chan_text_box)
self.setChannel(self._ccsds_channel)
if options.test == True or options.fromfile == True or options.frombitlog == True:
glow = 0.0
ghigh = 1.0
cur_g = 0.5
else:
g = self.u.get_gain_range()
cur_g = self._down_default_gain
# some configurations don't have gain control
if g.stop() <= g.start():
glow = 0.0
ghigh = 1.0
else:
glow = g.start()
ghigh = g.stop()
self._uhd_gain_slider = wx.BoxSizer(wx.HORIZONTAL)
form.slider_field(
parent=self.nb0.GetPage(0).GetWin(),
sizer=self._uhd_gain_slider,
label="USRP RX Gain",
weight=3,
min=int(glow),
max=int(ghigh),
value=cur_g,
callback=self.setDownGain
)
self.nb0.GetPage(0).Add(self._uhd_gain_slider)
#TX chain GUI components
if options.test == True or options.tofile == True or options.tonull == True:
gtxlow = 0.0
gtxhigh = 1.0
cur_gtx = 0.5
else:
gtx = self.u_tx.get_gain_range()
cur_gtx = self._up_default_gain
# some configurations don't have gain control
if gtx.stop() <= gtx.start():
gtxlow = 0.0
gtxhigh = 1.0
else:
gtxlow = gtx.start()
gtxhigh = gtx.stop()
self._up_en_chooser = forms.check_box(
parent=self.nb0.GetPage(1).GetWin(),
value='True',
callback=self.setUpEn,
label="TX Enable",
true='True',
false='False',
)
self.nb0.GetPage(1).Add(self._up_en_chooser)
self._uhd_tx_gain_slider = wx.BoxSizer(wx.HORIZONTAL)
form.slider_field(
parent=self.nb0.GetPage(1).GetWin(),
sizer=self._uhd_tx_gain_slider,
label="USRP TX Gain",
weight=3,
min=int(gtxlow),
max=int(gtxhigh),
value=cur_gtx,
callback=self.setUpGain
)
self.nb0.GetPage(1).Add(self._uhd_tx_gain_slider)
self._subcfreq_up_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_sub_freq,
callback=self.setUpSubFreq,
label="Uplink Subcarrier Frequency",
converter=forms.float_converter(),
)
self.nb0.GetPage(1).Add(self._subcfreq_up_text_box)
self._up_bitrate_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_bitrate,
callback=self.setUpBitrate,
label="Uplink Bitrate",
converter=forms.float_converter(),
)
self.nb0.GetPage(1).Add(self._up_bitrate_text_box)
self._up_data_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value="1234ABCD",
callback=self.txData,
label="TX Data",
converter=forms.str_converter(),
)
self.nb0.GetPage(1).Add(self._up_data_text_box)
self._up_mod_index_chooser = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_modulation_index,
callback=self.setUpModulationIndex,
label="Uplink Modulation Index",
converter=forms.float_converter(),
)
self.nb0.GetPage(1).Add(self._up_mod_index_chooser)
self._up_coding_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_coding_method,
callback=self.setUpCodingMethod,
label="Coding",
choices=['None', 'RS'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(1).Add(self._up_coding_chooser)
self._subcarrier_chooser = forms.radio_buttons(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_subcarrier,
callback=self.setUpSubcarrier,
label="Subcarrier Type",
choices=['Square','Sine'],
labels=[],
style=wx.RA_HORIZONTAL,
)
self.nb0.GetPage(1).Add(self._subcarrier_chooser)
self._up_conv_check_box = forms.check_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_conv_en,
callback=self.setUpConvEn,
label="Convolutional Encode",
true="True",
false="False",
)
self.nb0.GetPage(1).Add(self._up_conv_check_box)
self._up_pktlen_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_tm_len,
callback=self.setUpTMLen,
label="Uplink Packet Length (bits)",
converter=forms.float_converter(),
)
self.nb0.GetPage(1).Add(self._up_pktlen_text_box)
self._uhd_offset_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._uhd_carrier_offset,
callback=self.setUHDCarrierOffset,
label="USRP Offset Frequency (Hz)",
converter=forms.float_converter(),
)
self.nb0.GetPage(1).Add(self._uhd_offset_text_box)
self._sweep_gen_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value="rf2_1",
callback=self.freqSweep,
label="Frequency Sweep Profile",
converter=forms.str_converter(),
)
self.nb0.GetPage(1).Add(self._sweep_gen_text_box)
self._idle_sequence_text_box = forms.text_box(
parent=self.nb0.GetPage(1).GetWin(),
value=self._up_idle_sequence,
callback=self.setUpIdleSequence,
label="Uplink Idle Sequence",
converter=forms.str_converter(),
)
self.nb0.GetPage(1).Add(self._idle_sequence_text_box)
self._pn_ranging_text_box = forms.text_box(
parent=self.nb0.GetPage(2).GetWin(),
value="",
callback=self.rangePN,
label="Queue PN Ranging",
converter=forms.str_converter(),
)
self.nb0.GetPage(2).Add(self._pn_ranging_text_box)
self._sequential_ranging_text_box = forms.text_box(
parent=self.nb0.GetPage(2).GetWin(),
value="",
callback=self.rangeSequential,
label="Queue Sequential Ranging",
converter=forms.str_converter(),
)
self.nb0.GetPage(2).Add(self._sequential_ranging_text_box)
self.row2_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.freq_acq_button = forms.button(
parent=self.nb0.GetPage(2).GetWin(),
value='Acquire Carrier Offset',
callback=self.acquireCarrier,
choices=['Acquire Carrier Offset'],
style=wx.RA_HORIZONTAL,
)
self.carrier_offset_text = forms.static_text(
parent=self.nb0.GetPage(2).GetWin(),
value="",
label="",
converter=forms.str_converter(),
)
self.row2_sizer.Add(self.freq_acq_button, flag=wx.ALIGN_CENTER)
self.row2_sizer.Add(self.carrier_offset_text, flag=wx.ALIGN_CENTER)
self.nb0.GetPage(2).Add(self.row2_sizer)
self.file_sink = blocks.file_meta_sink(gr.sizeof_gr_complex, "iq_recording.dat", self._samples_per_second)
self.file_sink.close()
self.iq_recording_ctr = 0
# Selection logic to switch between recording and normal flowgraph routes
# NOTE: u_valve logic is implemented backwards in GNURadio....
#self.u_valve = blks2.valve(
# item_size=gr.sizeof_gr_complex,
# open=False
#)
# Temporary code used to verify coherent turnaround
self.turnaround_mixer = blocks.multiply_cc()
self.turnaround_mixer_source = analog.sig_source_c(self._down_samples_per_second, analog.GR_SIN_WAVE, -25e3, 1.0)
self.turnaround_iir = filter.single_pole_iir_filter_cc(0.0001)
self.turnaround_null = blocks.null_sink(gr.sizeof_float)
# PLL and associated carrier for tracking carrier frequency if residual carrier is used
self.carrier_tracking = sdrp.pll_freq_acq_cc(math.pi/2000, math.pi, -math.pi, int(options.acq_samples))
self.imag_to_float = blocks.complex_to_imag()
#Suppressed carrier requires costas after subcarrier mixer
self.subcarrier_costas = digital.costas_loop_cc(0.001, 2)
self.real_to_float = blocks.complex_to_real()
#Square wave subcarrier sync
self.subcarrier_sync = sdrp.square_sub_tracker_ff(0.001, 2*self._down_sub_freq/self._down_samples_per_second*1.0001, 2*self._down_sub_freq/self._down_samples_per_second*0.9999)
#Data sync
self.data_sync = sdrp.square_data_tracker_ff(0.001, self._down_bitrate/self._down_samples_per_second*1.001, self._down_bitrate/self._down_samples_per_second*0.999)
#Data framing
self.soft_correlator = sdrp.correlate_soft_access_tag_ff(conv_packed_binary_string_to_1_0_string('\x1A\xCF\xFC\x1D'), self._asm_threshold, "asm_corr")
self.conv_decoder = sdrp.ccsds_tm_conv_decoder("asm_corr")
self.de_randomizer = sdrp.ccsds_tm_derandomizer("asm_corr")
self.tm_framer = sdrp.ccsds_tm_framer(self._tm_packet_id, self._timestamp_id, "asm_corr", "rx_time", self._down_bitrate)
self.tm_framer.setFrameLength(self._tm_len)
self._current_scope_block = None
self._current_scoped_block = self.u
self._current_scoped_block_port = 0
self._recording = 'Off'
#TX path in flowgraph
self.pkt_gen_msgq = gr.msg_queue(10)
self.pkt_gen = sdrp.ccsds_tm_tx(self._tm_packet_id, self._timestamp_id, 1.0, 16, self.pkt_gen_msgq)
self.conj = blocks.conjugate_cc()
#Sweep generator for transponder lock
self.sweep_gen = sdrp.sweep_generator_cc(self._up_samples_per_second)
# DSSDR subcarrier mixer (either 25 kHz or 0 kHz depending on baud rate)
self.up_subcarrier_mixer = blocks.multiply_ff()
self.subcarrier_mixer_source_tx = analog.sig_source_f(self._up_samples_per_second, analog.GR_SQR_WAVE, 25e3, 2.0, -1.0)
self.phase_mod_tx = analog.phase_modulator_fc(self._up_modulation_index)
self.tx_attenuator = blocks.multiply_const_cc((0.1+0.0j))
#Add in bit recorder if needed
if self.options.bitlog:
self.bit_slicer = digital.binary_slicer_fb()
self.bit_recorder = blocks.file_sink(1, "bitstream_recording.out")
self.setDownCodingMethod(self._coding_method)
self.setUpCodingMethod("None")
self.setUpSubcarrier(self._up_subcarrier)
self.setDownBitrate(self._down_bitrate)
self.setUpBitrate(self._up_bitrate)
self.setDownModulationIndex(self._modulation_index)
self.setUpModulationIndex(self._up_modulation_index)
self.setDownConvEn(self._down_conv_en)
self.setUpConvEn(self._up_conv_en)
self.setUpIdleSequence(self._up_idle_sequence)
self.setDownRandomizerEn(self._down_randomizer_en)
self.setDownManchesterEn(self._down_manchester_en)
#Connection to outside world
self.socket_pdu = blocks.socket_pdu("TCP_SERVER", "127.0.0.1", "12902", 10000)
self.sdrp_interpreter = sdrp.sdrp_packet_interpreter()
self.msg_connect(self.tm_framer, "tm_frame_out", self.sdrp_interpreter, "sdrp_pdu_in")
self.msg_connect(self.sdrp_interpreter, "socket_pdu_out", self.socket_pdu, "pdus")
self.msg_connect(self.socket_pdu, "pdus", self.sdrp_interpreter, "socket_pdu_in")
self.msg_connect(self.sdrp_interpreter,"sdrp_pdu_out", self.pkt_gen, "ccsds_tx_msg_in")
if options.test == False and options.fromfile == False and options.frombitlog == False:
_threading.Thread(target=self.watchRef).start()
self.initialized = True
print "DS-SDR Initialized"
def __init__(self):
gr.top_block.__init__(self, "File Metadata Source")
Qt.QWidget.__init__(self)
self.setWindowTitle("File Metadata Source")
qtgui.util.check_set_qss()
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "file_metadata_source")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 200000
##################################################
# Blocks
##################################################
self.qtgui_time_sink_x_0 = qtgui.time_sink_c(
1024, #size
samp_rate, #samp_rate
'', #name
1 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0.set_y_label('Amplitude', "")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.0, 0,
0, "")
self.qtgui_time_sink_x_0.enable_autoscale(False)
self.qtgui_time_sink_x_0.enable_grid(False)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_time_sink_x_0.disable_legend()
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "blue"
]
styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(2):
if len(labels[i]) == 0:
if (i % 2 == 0):
self.qtgui_time_sink_x_0.set_line_label(
i, "Re{{Data {0}}}".format(i / 2))
else:
self.qtgui_time_sink_x_0.set_line_label(
i, "Im{{Data {0}}}".format(i / 2))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(
self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_time_sink_x_0_win)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1,
samp_rate, True)
self.blocks_tag_debug_0 = blocks.tag_debug(gr.sizeof_gr_complex * 1,
'Test', "")
self.blocks_tag_debug_0.set_display(True)
self.blocks_file_meta_source_0 = blocks.file_meta_source(
'C:\\Users\\Zyglabs\\Dropbox\\2017_05_Summer_Research\\EARS\\Refs\\GnuRadio\\Trials\\Trail2_file_metadata_sink.out',
False, True, '')
self.analog_agc2_xx_0 = analog.agc2_cc(1e-1, 1e-2, 1.0, 1.0)
self.analog_agc2_xx_0.set_max_gain(0.0)
##################################################
# Connections
##################################################
self.connect((self.analog_agc2_xx_0, 0), (self.qtgui_time_sink_x_0, 0))
self.connect((self.blocks_file_meta_source_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.analog_agc2_xx_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_tag_debug_0, 0))
