def __init__(self, addr, port, freq, rate, corr, ptt):
gr.hier_block2.__init__(
self,
name = "red_pitaya_sink",
input_signature = gr.io_signature(1, 1, gr.sizeof_gr_complex),
output_signature = gr.io_signature(0, 0, 0)
)
self.ctrl_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.ctrl_sock.connect((addr, port))
self.ctrl_sock.send(struct.pack('<I', 2))
self.data_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.data_sock.connect((addr, port))
self.data_sock.send(struct.pack('<I', 3))
fd = os.dup(self.data_sock.fileno())
self.null_sink = blocks.null_sink(gr.sizeof_gr_complex)
self.file_sink = blocks.file_descriptor_sink(gr.sizeof_gr_complex, fd)
self.set_freq(freq, corr)
self.set_rate(rate)
if ptt:
self.ptt = True
self.ctrl_sock.send(struct.pack('<I', 2<<28))
self.connect(self, self.file_sink)
else:
self.ptt = False
self.ctrl_sock.send(struct.pack('<I', 3<<28))
self.connect(self, self.null_sink)
def test_file_descriptor(self):
src_data = range(1000)
expected_result = range(1000)
snk2 = blocks.vector_sink_f()
with tempfile.NamedTemporaryFile() as temp:
fhandle0 = open(temp.name, "wb")
fd0 = fhandle0.fileno()
src = blocks.vector_source_f(src_data)
snk = blocks.file_descriptor_sink(gr.sizeof_float, fd0)
self.tb.connect(src, snk)
self.tb.run()
os.fsync(fd0)
fhandle0.close()
fhandle1 = open(temp.name, "rb")
fd1 = fhandle1.fileno()
src2 = blocks.file_descriptor_source(gr.sizeof_float, fd1, False)
self.tb.disconnect(src, snk)
self.tb.connect(src2, snk2)
self.tb.run()
os.fsync(fd1)
fhandle1.close()
result_data = snk2.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data)
self.assertEqual(len(snk2.tags()), 0)
def make_sink_to_process_stdin(process, itemsize=gr.sizeof_char):
"""Given a twisted Process, connect a sink to its stdin."""
fd_owned_by_twisted = process.pipes[0].fileno(
) # TODO: More public way to do this?
fd_owned_by_sink = os.dup(fd_owned_by_twisted)
process.closeStdin()
return blocks.file_descriptor_sink(itemsize, fd_owned_by_sink)
def test_descriptor_001(self):
src_data = range(1000)
expected_result = range(1000)
filename = "tmp.32f"
fhandle0 = open(filename, "wb")
fd0 = fhandle0.fileno()
src = blocks.vector_source_f(src_data)
snk = blocks.file_descriptor_sink(gr.sizeof_float, fd0)
self.tb.connect(src, snk)
self.tb.run()
os.fsync(fd0)
fhandle0.close()
fhandle1 = open(filename, "rb")
fd1 = fhandle1.fileno()
src2 = blocks.file_descriptor_source(gr.sizeof_float, fd1, False)
snk2 = blocks.vector_sink_f()
self.tb.disconnect(src, snk)
self.tb.connect(src2, snk2)
self.tb.run()
os.fsync(fd1)
fhandle1.close()
os.remove(filename)
result_data = snk2.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data)
def __init__(self, squelch, quad_rate, audio_rate, max_dev, out_scale,
freq, command):
gr.hier_block2.__init__(self, "FMtoCommand",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, gr.sizeof_gr_complex))
analog_pwr_squelch = analog.pwr_squelch_cc(squelch, 1e-4, 0, True)
analog_nbfm_rx = analog.nbfm_rx(
audio_rate=audio_rate,
quad_rate=quad_rate,
tau=75e-6,
max_dev=max_dev,
)
rational_resampler = filter.rational_resampler_fff(
interpolation=441,
decimation=500,
taps=None,
fractional_bw=None,
)
blocks_float_to_short = blocks.float_to_short(1, out_scale)
self.p = subprocess.Popen(command, shell=True, stdin=subprocess.PIPE)
sink = blocks.file_descriptor_sink(gr.sizeof_short * 1,
self.p.stdin.fileno())
self.connect(self, (analog_pwr_squelch, 0))
self.connect((analog_pwr_squelch, 0), (analog_nbfm_rx, 0))
self.connect((analog_nbfm_rx, 0), (rational_resampler, 0))
self.connect((rational_resampler, 0), (blocks_float_to_short, 0))
self.connect((blocks_float_to_short, 0), (sink, 0))
def test_file_descriptor(self):
src_data = range(1000)
expected_result = range(1000)
snk2 = blocks.vector_sink_f()
with tempfile.NamedTemporaryFile() as temp:
fhandle0 = open(temp.name, "wb")
fd0 = fhandle0.fileno()
src = blocks.vector_source_f(src_data)
snk = blocks.file_descriptor_sink(gr.sizeof_float, fd0)
self.tb.connect(src, snk)
self.tb.run()
os.fsync(fd0)
fhandle0.close()
fhandle1 = open(temp.name, "rb")
fd1 = fhandle1.fileno()
src2 = blocks.file_descriptor_source(gr.sizeof_float, fd1, False)
self.tb.disconnect(src, snk)
self.tb.connect(src2, snk2)
self.tb.run()
os.fsync(fd1)
fhandle1.close()
result_data = snk2.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data)
self.assertEqual(len(snk2.tags()), 0)
def __init__(self, addr, port, freq, rate, corr, ptt):
gr.hier_block2.__init__(
self,
name = "red_pitaya_sink",
input_signature = gr.io_signature(1, 1, gr.sizeof_gr_complex),
output_signature = gr.io_signature(0, 0, 0)
)
self.ctrl_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.ctrl_sock.connect((addr, port))
self.ctrl_sock.send(struct.pack('<I', 2))
self.data_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.data_sock.connect((addr, port))
self.data_sock.send(struct.pack('<I', 3))
fd = os.dup(self.data_sock.fileno())
self.null_sink = blocks.null_sink(gr.sizeof_gr_complex)
self.file_sink = blocks.file_descriptor_sink(gr.sizeof_gr_complex, fd)
self.set_freq(freq, corr)
self.set_rate(rate)
if ptt:
self.ptt = True
self.ctrl_sock.send(struct.pack('<I', 2<<28))
self.connect(self, self.file_sink)
else:
self.ptt = False
self.ctrl_sock.send(struct.pack('<I', 3<<28))
self.connect(self, self.null_sink)
def __init__(self, squelch, quad_rate, audio_rate, max_dev, out_scale, freq, command):
gr.hier_block2.__init__(self, "FMtoCommand",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, gr.sizeof_gr_complex))
analog_pwr_squelch = analog.pwr_squelch_cc(squelch, 1e-4, 0, True)
analog_nbfm_rx = analog.nbfm_rx(
audio_rate = audio_rate,
quad_rate = quad_rate,
tau = 75e-6,
max_dev = max_dev,
)
rational_resampler = filter.rational_resampler_fff(
interpolation = 441,
decimation = 500,
taps = None,
fractional_bw = None,
)
blocks_float_to_short = blocks.float_to_short(1, out_scale)
self.p = subprocess.Popen(command, shell = True, stdin = subprocess.PIPE)
sink = blocks.file_descriptor_sink(gr.sizeof_short*1, self.p.stdin.fileno())
self.connect(self, (analog_pwr_squelch, 0))
self.connect((analog_pwr_squelch, 0), (analog_nbfm_rx, 0))
self.connect((analog_nbfm_rx, 0), (rational_resampler, 0))
self.connect((rational_resampler, 0), (blocks_float_to_short, 0))
self.connect((blocks_float_to_short, 0), (sink, 0))
def __init__(self):
gr.top_block.__init__(self, "Top Block")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 1e6
self.center_freq = center_freq = 433.8e6
##################################################
# Blocks
##################################################
self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "" )
self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(center_freq, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(1, 0)
self.rtlsdr_source_0.set_gain_mode(False, 0)
self.rtlsdr_source_0.set_gain(10, 0)
self.rtlsdr_source_0.set_if_gain(20, 0)
self.rtlsdr_source_0.set_bb_gain(20, 0)
self.rtlsdr_source_0.set_antenna("", 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
self.blocks_file_descriptor_sink_0 = blocks.file_descriptor_sink(gr.sizeof_float*1, 1)
self.blocks_complex_to_mag_0 = blocks.complex_to_mag(1)
##################################################
# Connections
##################################################
self.connect((self.blocks_complex_to_mag_0, 0), (self.blocks_file_descriptor_sink_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.blocks_complex_to_mag_0, 0))
def __init__(self, itemsize, addr, port, server=False):
#init hier block
gr.hier_block2.__init__(
self, 'tcp_sink',
gr.io_signature(1, 1, itemsize),
gr.io_signature(0, 0, 0),
)
fd = _get_sock_fd(addr, port, server)
self.connect(self, blocks.file_descriptor_sink(itemsize, fd))
def __init__(self, num_ch, file_name, sensorLoc, sensorSys, sensor_id, sensor_key, center_freq, bandwidth, meas_duration, atten, samp_rate, avoid_LO):
gr.sync_block.__init__(self,
name="jsonfile_sink",
in_sig=[(bytes, num_ch)],
out_sig=None)
# Establish ssl socket connection to server
self.num_ch = num_ch
# Open file for output stream
self.file_name = file_name
self.f = open(self.file_name, 'wb')
self.srvr = blocks.file_descriptor_sink(self.num_ch * gr.sizeof_char, self.f.fileno())
self.sensorLoc = sensorLoc
self.sensorSys = sensorSys
self.sensor_id = sensor_id
self.sensor_key = sensor_key
self.center_freq = center_freq
self.bandwidth = bandwidth
self.meas_duration = meas_duration
self.atten = atten
self.samp_rate = samp_rate
self.avoid = avoid_LO
print ("Sensor ID: ", self.sensor_id)
# Send location and system info to server
loc_msg = self.read_json_from_file(self.sensorLoc)
sys_msg = self.read_json_from_file(self.sensorSys)
ts = long(round(getLocalUtcTimeStamp()))
print 'Serial no.', self.sensor_id
loc_msg['t'] = ts
loc_msg['SensorID'] = self.sensor_id
sys_msg['t'] = ts
sys_msg['SensorID'] = self.sensor_id
self.post_msg(loc_msg)
self.post_msg(sys_msg)
# Form data header
ts = long(round(getLocalUtcTimeStamp()))
f_start = self.center_freq - self.bandwidth / 2.0
if self.avoid:
#self.center_freq = self.center_freq + self.samp_rate/4.0
#print "Avoiding LO...\nShifting center Frequency to", self.center_freq
f_start = (self.center_freq - self.samp_rate/4) - self.bandwidth/2.0
f_stop = f_start + self.bandwidth
if self.avoid:
print "Avoiding LO, frequencies are shifted to: [",f_start/1e6, "MHz-",f_stop/1e6,"MHz ]"
mpar = Struct(fStart=f_start, fStop=f_stop, n=self.num_ch, td=-1, tm=self.meas_duration, Det='Average', Atten=self.atten)
# Need to add a field for overflow indicator
data_hdr = Struct(Ver='1.0.12', Type='Data', SensorID=self.sensor_id, SensorKey=self.sensor_key, t=ts, Sys2Detect='LTE', Sensitivity='Low', mType='FFT-Power', t1=ts, a=1, nM=-1, Ta=-1, OL='NaN', wnI=-77.0, Comment='Using hard-coded (not detected) system noise power for wnI', Processed='False', DataType = 'Binary - int8', ByteOrder='N/A', Compression='None', mPar=mpar)
self.post_msg(data_hdr)
self.f.flush()
date_str = formatTimeStampLong(ts, loc_msg['TimeZone'])
print date_str, "fc =", self.center_freq/1e6, "MHz. Writing data to file", self.file_name
def __init__(self, itemsize, addr, port, server=False):
#init hier block
gr.hier_block2.__init__(
self, 'tcp_sink',
gr.io_signature(1, 1, itemsize),
gr.io_signature(0, 0, 0),
)
fd = _get_sock_fd(addr, port, server)
self.connect(self, blocks.file_descriptor_sink(itemsize, fd))
def __init__(self, device, rate, ppm, fd):
self.rate = rate
gr.top_block.__init__(self, "Top Block")
self.osmosdr_source = osmosdr.source(device)
self.osmosdr_source.set_sample_rate(int(rate))
self.osmosdr_source.set_freq_corr(ppm, 0)
self.osmosdr_source.set_dc_offset_mode(0, 0)
self.osmosdr_source.set_iq_balance_mode(2, 0)
self.osmosdr_source.set_antenna("", 0)
#self.osmosdr_source.set_bandwidth(0, 0)
self.blocks_file_descriptor_sink_0 = blocks.file_descriptor_sink(gr.sizeof_float*2, fd)
self.connect((self.osmosdr_source, 0), (self.blocks_file_descriptor_sink_0, 0))
def __init__(self, args, itemsize=gr.sizeof_char): gr.hier_block2.__init__( self, 'subprocess ' + repr(args), gr.io_signature(1, 1, itemsize), gr.io_signature(0, 0, 0), ) self.__p = subprocess.Popen( args=args, stdin=subprocess.PIPE, stdout=None, stderr=None, close_fds=True) # we dup the fd because the stdin object and file_descriptor_sink both expect to own it fd_owned_by_sink = os.dup(self.__p.stdin.fileno()) self.__p.stdin.close() # not going to use self.connect( self, blocks.file_descriptor_sink(itemsize, fd_owned_by_sink))
def __init__(self, device, rate, ppm, fd):
self.rate = rate
gr.top_block.__init__(self, "Top Block")
self.osmosdr_source = osmosdr.source(device)
self.osmosdr_source.set_sample_rate(int(rate))
self.osmosdr_source.set_freq_corr(ppm, 0)
self.osmosdr_source.set_dc_offset_mode(0, 0)
self.osmosdr_source.set_iq_balance_mode(2, 0)
self.osmosdr_source.set_antenna("", 0)
#self.osmosdr_source.set_bandwidth(0, 0)
self.blocks_file_descriptor_sink_0 = blocks.file_descriptor_sink(
gr.sizeof_float * 2, fd)
self.connect((self.osmosdr_source, 0),
(self.blocks_file_descriptor_sink_0, 0))
def __init__(self,
squelch,
ch_width,
max_dev,
out_scale,
freq,
command,
do_audio=False):
gr.hier_block2.__init__(self, "FMtoCommand",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0, 0, gr.sizeof_gr_complex))
self.analog_pwr_squelch = analog.pwr_squelch_cc(squelch, 1e-4, 0, True)
self.analog_nbfm_rx = analog.nbfm_rx(
audio_rate=ch_width,
quad_rate=ch_width,
tau=75e-6,
max_dev=max_dev,
)
self.blocks_float_to_short = blocks.float_to_short(1, out_scale)
# OSX: if you get Resource Temporarily Unavailable you probably need to increase maxproc, eg
# sudo launchctl limit maxproc 2000 3000
logger.debug("Channel %.3f: Starting %s" % (freq / 1e6, str(command)))
self.p = subprocess.Popen(command,
shell=True,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
self.sink = blocks.file_descriptor_sink(gr.sizeof_short * 1,
self.p.stdin.fileno())
self.connect(self, (self.analog_pwr_squelch, 0))
self.connect((self.analog_pwr_squelch, 0), (self.analog_nbfm_rx, 0))
self.connect((self.analog_nbfm_rx, 0), (self.blocks_float_to_short, 0))
self.connect((self.blocks_float_to_short, 0), (self.sink, 0))
if do_audio:
self.resampler = grfilter.rational_resampler_fff(
interpolation=441,
decimation=425,
taps=None,
fractional_bw=None)
self.mult = blocks.multiply_const_vff((0.2, ))
self.audio_sink = audio.sink(22050, '', True)
self.connect((self.analog_nbfm_rx, 0), (self.resampler, 0))
self.connect((self.resampler, 0), (self.mult, 0))
self.connect((self.mult, 0), (self.audio_sink, 0))
def __init__(self, filename, fd):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
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", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.sample_rate = sample_rate = (6000000.0 * 8) / 7
self.channel_hz = channel_hz = 6e6
##################################################
# Blocks
##################################################
self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char * 1512,
filename, False)
self.blocks_file_sink_0_0_0 = blocks.file_descriptor_sink(
gr.sizeof_char * 1512, fd)
# self.blocks_file_sink_0_0_0.set_unbuffered(False)
##################################################
# Connections
##################################################
self.connect((self.blocks_file_source_0, 0),
(self.blocks_file_sink_0_0_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Top Block")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 1e6
self.center_freq = center_freq = 433.8e6
##################################################
# Blocks
##################################################
self.rtlsdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " +
"")
self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(center_freq, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(1, 0)
self.rtlsdr_source_0.set_gain_mode(False, 0)
self.rtlsdr_source_0.set_gain(10, 0)
self.rtlsdr_source_0.set_if_gain(20, 0)
self.rtlsdr_source_0.set_bb_gain(20, 0)
self.rtlsdr_source_0.set_antenna("", 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
self.blocks_file_descriptor_sink_0 = blocks.file_descriptor_sink(
gr.sizeof_float * 1, 1)
self.blocks_complex_to_mag_0 = blocks.complex_to_mag(1)
##################################################
# Connections
##################################################
self.connect((self.blocks_complex_to_mag_0, 0),
(self.blocks_file_descriptor_sink_0, 0))
self.connect((self.rtlsdr_source_0, 0),
(self.blocks_complex_to_mag_0, 0))
def __init__(self, input_file, output_file):
gr.top_block.__init__(self)
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 2048000
##################################################
# Blocks
##################################################
self.low_pass_filter_1 = filter.fir_filter_fff(1, firdes.low_pass(
1, samp_rate, 85000, 2000, firdes.WIN_HAMMING, 6.76))
self.low_pass_filter_0 = filter.fir_filter_ccf(1, firdes.low_pass(
1, samp_rate, 200000, 1000, firdes.WIN_HAMMING, 6.76))
if input_file != None:
self.blocks_wavfile_source_0 = blocks.wavfile_source(input_file, False)
else:
import osmosdr
self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "" )
self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(433463000, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_0.set_gain_mode(False, 0)
self.rtlsdr_source_0.set_gain(10, 0)
self.rtlsdr_source_0.set_if_gain(20, 0)
self.rtlsdr_source_0.set_bb_gain(20, 0)
self.rtlsdr_source_0.set_antenna("", 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_float_to_complex_0 = blocks.float_to_complex(1)
if output_file == '-':
self.blocks_file_sink_0 = blocks.file_descriptor_sink(4, 1)
else:
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*1, output_file, False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_add_const_vxx_0 = blocks.add_const_vff((0.00, ))
self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, -420000, 1, 0)
self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf(1)
##################################################
# Connections
##################################################
self.connect((self.analog_quadrature_demod_cf_0, 0), (self.low_pass_filter_1, 0))
self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 1))
self.connect((self.blocks_add_const_vxx_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_multiply_xx_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.analog_quadrature_demod_cf_0, 0))
self.connect((self.low_pass_filter_1, 0), (self.blocks_add_const_vxx_0, 0))
if input_file != None:
self.connect((self.blocks_wavfile_source_0, 1), (self.blocks_float_to_complex_0, 0))
self.connect((self.blocks_wavfile_source_0, 0), (self.blocks_float_to_complex_0, 1))
self.connect((self.blocks_float_to_complex_0, 0), (self.blocks_multiply_xx_0, 0))
else:
self.connect((self.rtlsdr_source_0, 0), (self.blocks_multiply_xx_0, 0))
def __init__(self,
fmt,
item_size,
channels,
is_complex,
sample_rate,
aggregate_channel_count=1,
flip_complex=False,
baseband_freq=None,
decimation=1,
scale=1.0,
overlap=None,
slide_size=None,
fft_size=None,
jump_step=None,
x_slip=None,
mode='pipe',
buffered=True,
kill_on_del=True,
memory=None,
peak_hold=False,
**kwds):
gr.hier_block2.__init__(self, "baudline_sink",
gr.io_signature(1, 1, item_size),
gr.io_signature(0, 0, 0))
baudline_path = gr.prefs().get_string('baudline', 'path', 'baudline')
#tf = tempfile.NamedTemporaryFile(delete=False)
#tf.write(gp)
#tf.close()
#print tf.name
self.mode = mode
self.kill_on_del = kill_on_del
if mode == 'fifo':
fifo_name = 'baudline_fifo'
self.tmpdir = tempfile.mkdtemp()
self.filename = os.path.join(self.tmpdir, fifo_name)
print(self.filename)
try:
os.mkfifo(self.filename)
except OSError as e:
print("Failed to create FIFO: %s" % e)
raise
baudline_exec = [
baudline_path,
"-stdin",
"-record",
"-spacebar",
"recordpause",
"-samplerate",
str(int(sample_rate)),
"-channels",
str(channels * aggregate_channel_count),
"-format",
fmt,
#"-backingstore",
# #
#"-threads",
#"-pipeline",
#"-memory", # MB
#"-verticalsync"
#"-realtime",
#"-psd"
#"-reversetimeaxis",
#"-overclock",
#"-debug",
#"-debugtimer", str(1000)
#"-debugfragments",
#"-debugcadence",
#"-debugjitter",
#"-debugrate",
#"-debugmeasure
]
if is_complex:
baudline_exec += ["-quadrature"]
if flip_complex:
baudline_exec += ["-flipcomplex"]
if baseband_freq is not None and baseband_freq > 0:
baudline_exec += ["-basefrequency", str(baseband_freq)]
if decimation > 1:
baudline_exec += ["-decimateby", str(decimation)]
if scale != 1.0:
baudline_exec += ["-scaleby", str(scale)]
if overlap is not None and overlap > 0:
baudline_exec += ["-overlap", str(overlap)]
#"-slidesize"
if slide_size is not None and slide_size > 0:
baudline_exec += ["-slidesize", str(slide_size)]
if fft_size is not None and fft_size > 0:
baudline_exec += ["-fftsize", str(fft_size)]
if jump_step is not None and jump_step > 0:
baudline_exec += ["-jumpstep", str(jump_step)]
if x_slip is not None and x_slip > 0:
baudline_exec += ["-xslip", str(x_slip)]
if memory is not None and memory > 0:
baudline_exec += ["-memory", str(memory)]
if peak_hold:
baudline_exec += ["-peakhold"]
for k in kwds.keys():
arg = str(k).strip()
if arg[0] != '-':
arg = "-" + arg
baudline_exec += [arg]
val = kwds[k]
if val is not None:
val = str(val).strip()
if val.find(' ') > -1 and len(val) > 1:
if val[0] != '\"':
val = "\"" + val
if val[-1] != '\"':
val += "\""
baudline_exec += [val]
if mode == 'fifo':
baudline_exec += ["<", self.filename]
#baudline_exec = ["cat", self.filename, "|"] + baudline_exec
baudline_exec = [" ".join(baudline_exec)]
self.p = None
#res = 0
try:
#res = subprocess.call(gp_exec)
print(baudline_exec)
if mode == 'pipe':
self.p = subprocess.Popen(
baudline_exec, stdin=subprocess.PIPE
) # , stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=16384 or -1
elif mode == 'fifo':
self.p = subprocess.Popen(baudline_exec, shell=True)
#self.p.communicate(input=)
#self.p.stdin.write()
#self.p.wait()
#except KeyboardInterrupt:
# print "Caught CTRL+C"
except Exception as e:
print(e)
raise
#if self.p is not None and not self.p.returncode == 0:
# print "Failed to run subprocess (result: %d)" % (self.p.returncode)
#if res != 0:
# print "Failed to run subprocess (result: %d)" % (res)
if mode == 'pipe':
print("==> Using FD:", self.p.stdin.fileno())
self.file_sink = blocks.file_descriptor_sink(
item_size, self.p.stdin.fileno()) # os.dup
elif mode == 'fifo':
self.file_sink = blocks.file_sink(item_size,
self.filename) # os.dup
self.file_sink.set_unbuffered(
not buffered) # Flowgraph won't die if baudline exits
self.connect(self, self.file_sink)
#self.p.stdin.write() #self.p.wait() #except KeyboardInterrupt: # print "Caught CTRL+C" except Exception, e: print e raise #if self.p is not None and not self.p.returncode == 0: # print "Failed to run subprocess (result: %d)" % (self.p.returncode) #if res != 0: # print "Failed to run subprocess (result: %d)" % (res) if mode == 'pipe': print "==> Using FD:", self.p.stdin.fileno() self.file_sink = blocks.file_descriptor_sink(item_size, self.p.stdin.fileno()) # os.dup elif mode == 'fifo': self.file_sink = blocks.file_sink(item_size, self.filename) # os.dup self.file_sink.set_unbuffered(not buffered) # Flowgraph won't die if baudline exits self.connect(self, self.file_sink) def __del__(self): #os.unlink(tf.name) if self.p is not None: # Won't work in FIFO mode as it blocks if self.kill_on_del: print "==> Killing baudline..." #self.p.kill() #self.p.terminate() os.kill(self.p.pid, signal.SIGTERM)
def __init__(self):
gr.top_block.__init__(self)
options = get_options()
bitrate = 8000
channel_bw = options.channel_bandwidth
chan0_freq = 358400000
self.rfgain = options.gain
self.channels = [ int(ch) for ch in options.channels.split(',') if ch ]
self.ch_freqs = [ ch * channel_bw + chan0_freq for ch in self.channels ]
self.ch_freqs.extend(
[ int(f) for f in options.channels_by_freq.split(',') if f ])
while len(self.channels) < len(self.ch_freqs):
self.channels.append(-1)
if options.frequency is None:
self.ifreq = (max(self.ch_freqs) + min(self.ch_freqs)) / 2
else:
self.ifreq = options.frequency
self.src = osmosdr.source(options.args)
self.src.set_center_freq(self.ifreq)
self.src.set_sample_rate(options.sample_rate)
self.src.set_freq_corr(options.ppm, 0)
if self.rfgain is None:
self.src.set_gain_mode(True, 0)
self.iagc = 1
self.rfgain = 0
else:
self.iagc = 0
self.src.set_gain_mode(False)
self.src.set_gain(self.rfgain)
self.src.set_if_gain(37)
# may differ from the requested rate
sample_rate = int(self.src.get_sample_rate())
sys.stderr.write("sample rate: %d\n" % (sample_rate))
first_decim = int(options.sample_rate / bitrate / 2)
sys.stderr.write("decim: %d\n" % (first_decim))
out_sample_rate=sample_rate/first_decim
sys.stderr.write("output sample rate: %d\n" % (out_sample_rate))
sps=out_sample_rate/bitrate
sys.stderr.write("samples per symbol: %d\n" % (sps))
self.tuners = []
self.afc_probes = []
if len(self.channels) != 1:
if options.output_file:
if options.output_file.find('%%') == -1:
raise ValueError('Output name template missing "%%".')
elif options.output_pipe:
if options.output_pipe.find('%%') == -1:
raise ValueError('Output name template missing "%%".')
else:
raise ValueError('WTF')
for ch in range(0,len(self.channels)):
bw = (9200 + options.afc_ppm_threshold)/2
taps = filter.firdes.low_pass(1.0, sample_rate, bw, bw*options.transition_width, filter.firdes.WIN_HANN)
offset = self.ch_freqs[ch] - self.ifreq
sys.stderr.write("channel[%d]: %d frequency=%d, offset=%d Hz\n" % (ch, self.channels[ch], self.ch_freqs[ch], offset))
tuner = filter.freq_xlating_fir_filter_ccc(first_decim, taps, offset, sample_rate)
self.tuners.append(tuner)
demod = digital.gmsk_demod(samples_per_symbol=sps)
fname = self.channels[ch]
if fname == -1:
fname = self.ch_freqs[ch]
if options.output_pipe is None:
file = options.output_file.replace('%%', str(fname))
output = blocks.file_sink(gr.sizeof_char, file)
else:
cmd = options.output_pipe.replace('%%', str(fname))
pipe = subprocess.Popen(cmd, stdin=subprocess.PIPE, shell=True)
fd = pipe.stdin.fileno()
output = blocks.file_descriptor_sink(gr.sizeof_char, fd)
self.connect((self.src, 0), (tuner, 0))
self.connect((tuner, 0), (demod, 0))
self.connect((demod, 0), (output, 0))
afc_decimation = 32000
afc_demod = analog.quadrature_demod_cf(sample_rate/first_decim/(2*math.pi*afc_decimation))
integrate = blocks.integrate_ff(afc_decimation)
afc_probe = blocks.probe_signal_f()
self.afc_probes.append(afc_probe)
self.connect((tuner, 0), (afc_demod,0))
self.connect((afc_demod, 0), (integrate,0))
self.connect((integrate, 0), (afc_probe, 0))
def _variable_function_probe_0_probe():
while True:
time.sleep(options.afc_period)
for ch in range(0,len(self.channels)):
err = self.afc_probes[ch].level()
if abs(err) < options.afc_ppm_threshold:
continue
freq = self.tuners[ch].center_freq() + err * options.afc_gain
self.tuners[ch].set_center_freq(freq)
if self.channels[ch] == -1:
sys.stderr.write("Freq %d freq err: %5.0f\tfreq: %f\n" % (self.ch_freqs[ch], err, freq))
else:
sys.stderr.write("Chan %d freq err: %5.0f\tfreq: %f\n" % (self.channels[ch], err, freq))
sys.stderr.write("\n")
_variable_function_probe_0_thread = threading.Thread(target=_variable_function_probe_0_probe)
_variable_function_probe_0_thread.daemon = True
_variable_function_probe_0_thread.start()
def __init__(self):
gr.top_block.__init__(self)
bitrate = 8000
channel_bw = 12500
chan0_freq = 358400000
options = get_options()
self.rfgain = options.gain
self.channels = [ int(ch) for ch in options.channels.split(',') if ch ]
self.ch_freqs = [ ch * channel_bw + chan0_freq for ch in self.channels ]
self.ch_freqs.extend(
[ int(f) for f in options.channels_by_freq.split(',') if f ])
while len(self.channels) < len(self.ch_freqs):
self.channels.append(-1)
if options.frequency is None:
self.ifreq = (max(self.ch_freqs) + min(self.ch_freqs)) / 2 / channel_bw * channel_bw
else:
self.ifreq = options.frequency
ch0 = (self.ifreq - chan0_freq ) / channel_bw
n = options.sample_rate / channel_bw
s = options.sample_rate / bitrate / 2
c = ''
for ch in range(0,len(self.channels)):
c = c + '%i,'%((self.channels[ch] - ch0)%n)
c=c[:-1]
self.src = osmosdr.source(options.args)
self.src.set_center_freq(self.ifreq)
self.src.set_sample_rate(options.sample_rate)
self.src.set_freq_corr(options.ppm, 0)
fcl_args = ['./fcl', '-n', '%i'%n, '-s', '%i'%s, '-t', '2', '-c', '%s'%c, '-f', './fir.py %i 7900 2000 rcos'%options.sample_rate, '-o', '/dev/stdout']
sys.stderr.write(string.join(fcl_args))
self.fcl = subprocess.Popen(fcl_args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
self.fcl_in = blocks.file_descriptor_sink(gr.sizeof_gr_complex*1, self.fcl.stdin.fileno())
self.fcl_out = blocks.file_descriptor_source(gr.sizeof_gr_complex*1, self.fcl.stdout.fileno(), False)
self.deinterleave = blocks.deinterleave(gr.sizeof_gr_complex*1, 1)
self.connect((self.src, 0), (self.fcl_in, 0))
self.connect((self.fcl_out, 0), (self.deinterleave, 0))
if self.rfgain is None:
self.src.set_gain_mode(True, 0)
self.iagc = 1
self.rfgain = 0
else:
self.iagc = 0
self.src.set_gain_mode(False)
self.src.set_gain(-9.7)
self.src.set_gain(self.rfgain)
self.src.set_if_gain(37)
# may differ from the requested rate
sample_rate = int(self.src.get_sample_rate())
sys.stderr.write("sample rate: %d\n" % (sample_rate))
first_decim = int(options.sample_rate / bitrate / 2)
sys.stderr.write("decim: %d\n" % (first_decim))
out_sample_rate=sample_rate/first_decim
sys.stderr.write("output sample rate: %d\n" % (out_sample_rate))
sps=out_sample_rate/bitrate
sys.stderr.write("samples per symbol: %d\n" % (sps))
self.tuners = []
self.afc_probes = []
if len(self.channels) != 1:
if options.output_file:
if options.output_file.find('%%') == -1:
raise ValueError('Output name template missing "%%".')
elif options.output_pipe:
if options.output_pipe.find('%%') == -1:
raise ValueError('Output name template missing "%%".')
else:
raise ValueError('WTF')
for ch in range(0,len(self.channels)):
bw = (9200 + options.afc_ppm_threshold)/2
taps = filter.firdes.low_pass(1.0,out_sample_rate, bw, bw*options.transition_width, filter.firdes.WIN_HANN)
# offset = self.ch_freqs[ch] - self.ifreq
offset = 0
sys.stderr.write("channel[%d]: %d frequency=%d, offset=%d Hz\n" % (ch, self.channels[ch], self.ch_freqs[ch], offset))
tuner = filter.freq_xlating_fir_filter_ccc(1, taps, offset, out_sample_rate)
self.tuners.append(tuner)
demod = digital.gmsk_demod(samples_per_symbol=sps)
fname = self.channels[ch]
if fname == -1:
fname = self.ch_freqs[ch]
if options.output_pipe is None:
file = options.output_file.replace('%%', str(fname))
output = blocks.file_sink(gr.sizeof_char, file)
else:
cmd = options.output_pipe.replace('%%', str(fname))
pipe = subprocess.Popen(cmd, stdin=subprocess.PIPE, shell=True)
fd = pipe.stdin.fileno()
output = blocks.file_descriptor_sink(gr.sizeof_char, fd)
self.connect((self.deinterleave, ch), (tuner, 0))
self.connect((tuner, 0), (demod, 0))
self.connect((demod, 0), (output, 0))
afc_decimation = 32000
afc_demod = analog.quadrature_demod_cf(sample_rate/first_decim/(2*math.pi*afc_decimation))
integrate = blocks.integrate_ff(afc_decimation)
afc_probe = blocks.probe_signal_f()
self.afc_probes.append(afc_probe)
self.connect((tuner, 0), (afc_demod,0))
self.connect((afc_demod, 0), (integrate,0))
self.connect((integrate, 0), (afc_probe, 0))
def _variable_function_probe_0_probe():
while True:
time.sleep(options.afc_period)
for ch in range(0,len(self.channels)):
err = self.afc_probes[ch].level()
if abs(err) < options.afc_ppm_threshold:
continue
freq = self.tuners[ch].center_freq() + err * options.afc_gain
self.tuners[ch].set_center_freq(freq)
if self.channels[ch] == -1:
sys.stderr.write("Freq %d freq err: %5.0f\tfreq: %f\n" % (self.ch_freqs[ch], err, freq))
else:
sys.stderr.write("Chan %d freq err: %5.0f\tfreq: %f\n" % (self.channels[ch], err, freq))
sys.stderr.write("\n")
_variable_function_probe_0_thread = threading.Thread(target=_variable_function_probe_0_probe)
_variable_function_probe_0_thread.daemon = True
_variable_function_probe_0_thread.start()
def __init__(self,
basePort=22200,
dataPort=1,
hostnameOrDevice='/dev/ndr47x',
ifname='eth6',
radioType='ndr304',
udpPortOrBaudrate=921600,
verbose=1,
vitaLevel=3,
wbfftRate=8,
wbfftSize=10,
wideband2=0):
gr.top_block.__init__(self, "NDR Demo GUI (QT)")
Qt.QWidget.__init__(self)
self.setWindowTitle("NDR Demo GUI (QT)")
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", "ndr_qt_demo_gui")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Parameters
##################################################
self.basePort = basePort
self.dataPort = dataPort
self.hostnameOrDevice = hostnameOrDevice
self.ifname = ifname
self.radioType = radioType
self.udpPortOrBaudrate = udpPortOrBaudrate
self.verbose = verbose
self.vitaLevel = vitaLevel
self.wbfftRate = wbfftRate
self.wbfftSize = wbfftSize
self.wideband2 = wideband2
##################################################
# Variables
##################################################
self.radioClass = radioClass = crd.getRadioClass(radioType, )
self.ch2_wb = ch2_wb = bool(
wideband2) or radioType.strip().lower() in ("ndr304", "ndr472")
self.ch2_rateSet = ch2_rateSet = radioClass.getWbddcRateSet(
) if ch2_wb else radioClass.getNbddcRateSet()
self.ch1_rateSet = ch1_rateSet = radioClass.getWbddcRateSet()
self.ch2_rateIndex = ch2_rateIndex = sorted(ch2_rateSet.keys())[0]
self.ch1_rateIndex = ch1_rateIndex = sorted(ch1_rateSet.keys())[0]
self.radioRsp = radioRsp = ""
self.macAndIpList = macAndIpList = crd.getInterfaceAddresses(ifname)
self.ch2_rfAttenRange = ch2_rfAttenRange = [
int(i) for i in radioClass.getTunerAttenuationRange()
] if ch2_wb else [0, 0]
self.ch2_fs = ch2_fs = ch2_rateSet[ch2_rateIndex]
self.ch2_channelList = ch2_channelList = radioClass.getWbddcIndexRange(
)[1::2] if ch2_wb else radioClass.getNbddcIndexRange()
self.ch1_updateRate = ch1_updateRate = wbfftRate
self.ch1_fs = ch1_fs = ch1_rateSet[ch1_rateIndex]
self.ch1_fftSize = ch1_fftSize = int(2**wbfftSize)
self.ch1_channelList = ch1_channelList = radioClass.getWbddcIndexRange(
)[0::2] if ch2_wb else radioClass.getWbddcIndexRange()
self.udpPortList = udpPortList = [basePort, basePort + 1]
self.radioRspDisplay = radioRspDisplay = radioRsp
self.radioCmd = radioCmd = ''
self.logfile = logfile = os.path.join(
"/public", "ndrDemoGui", "ndrCmd.%s.log" %
datetime.datetime.now().strftime("%y%m%d-%H%M%S"))
self.ipAddress = ipAddress = macAndIpList[1]
self.fftColSpan = fftColSpan = 6
self.ch2_updateRate = ch2_updateRate = ch1_updateRate if ch2_wb else 4 * ch1_updateRate
self.ch2_rfFreqRange = ch2_rfFreqRange = [
int(i / 1e6) for i in radioClass.getTunerFrequencyRange()
] if ch2_wb else [0, 0]
self.ch2_rfFreq = ch2_rfFreq = int(
sum(radioClass.getTunerFrequencyRange()) / 2e6) if ch2_wb else 0
self.ch2_rfAtten = ch2_rfAtten = ch2_rfAttenRange[0]
self.ch2_index = ch2_index = ch2_channelList[0]
self.ch2_fsLabel = ch2_fsLabel = "%sHz" % (num_to_str(ch2_fs))
self.ch2_fftSize = ch2_fftSize = ch1_fftSize if ch2_wb else ch1_fftSize / 2
self.ch2_ddcFreq = ch2_ddcFreq = 0
self.ch1_rfFreq = ch1_rfFreq = int(
sum(radioClass.getTunerFrequencyRange()) / 2e6)
self.ch1_rfAtten = ch1_rfAtten = int(
radioClass.getTunerAttenuationRange()[0])
self.ch1_index = ch1_index = ch1_channelList[0]
self.ch1_fsLabel = ch1_fsLabel = "%sHz" % (num_to_str(ch1_fs))
self.ch1_ddcFreq = ch1_ddcFreq = 0
##################################################
# Blocks
##################################################
self._ch2_rfFreq_range = Range(
int(radioClass.getTunerFrequencyRange()[0] / 1e6) if ch2_wb else 0,
int(radioClass.getTunerFrequencyRange()[1] / 1e6) if ch2_wb else 0,
20,
int(sum(radioClass.getTunerFrequencyRange()) /
2e6) if ch2_wb else 0, 200)
self._ch2_rfFreq_win = RangeWidget(self._ch2_rfFreq_range,
self.set_ch2_rfFreq,
'RF Freq (MHz)', "counter_slider",
int)
self.top_grid_layout.addWidget(self._ch2_rfFreq_win, 2, fftColSpan + 0,
1, fftColSpan / 2)
self._ch2_rfAtten_range = Range(ch2_rfAttenRange[0],
ch2_rfAttenRange[1], 1,
ch2_rfAttenRange[0], 200)
self._ch2_rfAtten_win = RangeWidget(self._ch2_rfAtten_range,
self.set_ch2_rfAtten,
'RF Atten (dB)', "counter_slider",
int)
self.top_grid_layout.addWidget(self._ch2_rfAtten_win, 2,
fftColSpan + fftColSpan / 2, 1,
fftColSpan / 2)
self._ch2_rateIndex_options = sorted(ch2_rateSet.keys())
self._ch2_rateIndex_labels = map(str, self._ch2_rateIndex_options)
self._ch2_rateIndex_tool_bar = Qt.QToolBar(self)
self._ch2_rateIndex_tool_bar.addWidget(Qt.QLabel('Rate Index' + ": "))
self._ch2_rateIndex_combo_box = Qt.QComboBox()
self._ch2_rateIndex_tool_bar.addWidget(self._ch2_rateIndex_combo_box)
for label in self._ch2_rateIndex_labels:
self._ch2_rateIndex_combo_box.addItem(label)
self._ch2_rateIndex_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._ch2_rateIndex_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._ch2_rateIndex_options.index(i)))
self._ch2_rateIndex_callback(self.ch2_rateIndex)
self._ch2_rateIndex_combo_box.currentIndexChanged.connect(
lambda i: self.set_ch2_rateIndex(self._ch2_rateIndex_options[i]))
self.top_grid_layout.addWidget(self._ch2_rateIndex_tool_bar, 1,
fftColSpan + 1, 1, 1)
self._ch2_index_options = ch2_channelList
self._ch2_index_labels = map(str, self._ch2_index_options)
self._ch2_index_tool_bar = Qt.QToolBar(self)
self._ch2_index_tool_bar.addWidget(
Qt.QLabel("%sDDC" % ("WB" if ch2_wb else "NB") + ": "))
self._ch2_index_combo_box = Qt.QComboBox()
self._ch2_index_tool_bar.addWidget(self._ch2_index_combo_box)
for label in self._ch2_index_labels:
self._ch2_index_combo_box.addItem(label)
self._ch2_index_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._ch2_index_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._ch2_index_options.index(i)))
self._ch2_index_callback(self.ch2_index)
self._ch2_index_combo_box.currentIndexChanged.connect(
lambda i: self.set_ch2_index(self._ch2_index_options[i]))
self.top_grid_layout.addWidget(self._ch2_index_tool_bar, 1,
fftColSpan + 0, 1, 1)
self._ch2_ddcFreq_range = Range(
(radioClass.getWbddcFrequencyRange()
if ch2_wb else radioClass.getNbddcFrequencyRange())[0] / 1e3,
(radioClass.getWbddcFrequencyRange() if ch2_wb else
radioClass.getNbddcFrequencyRange())[1] / 1e3, 10, 0, 200)
self._ch2_ddcFreq_win = RangeWidget(self._ch2_ddcFreq_range,
self.set_ch2_ddcFreq, 'Freq (kHz)',
"counter_slider", float)
self.top_grid_layout.addWidget(self._ch2_ddcFreq_win, 1,
fftColSpan + fftColSpan / 2, 1,
fftColSpan / 2)
self._ch1_rfFreq_range = Range(
int(radioClass.getTunerFrequencyRange()[0] / 1e6),
int(radioClass.getTunerFrequencyRange()[1] / 1e6), 20,
int(sum(radioClass.getTunerFrequencyRange()) / 2e6), 200)
self._ch1_rfFreq_win = RangeWidget(self._ch1_rfFreq_range,
self.set_ch1_rfFreq,
'RF Freq (MHz)', "counter_slider",
int)
self.top_grid_layout.addWidget(self._ch1_rfFreq_win, 2, 0, 1,
fftColSpan / 2)
self._ch1_rfAtten_range = Range(
int(radioClass.getTunerAttenuationRange()[0]),
int(radioClass.getTunerAttenuationRange()[1]), 1,
int(radioClass.getTunerAttenuationRange()[0]), 200)
self._ch1_rfAtten_win = RangeWidget(self._ch1_rfAtten_range,
self.set_ch1_rfAtten,
'RF Atten (dB)', "counter_slider",
int)
self.top_grid_layout.addWidget(self._ch1_rfAtten_win, 2,
fftColSpan / 2, 1, fftColSpan / 2)
self._ch1_rateIndex_options = sorted(ch1_rateSet.keys())
self._ch1_rateIndex_labels = map(str, self._ch1_rateIndex_options)
self._ch1_rateIndex_tool_bar = Qt.QToolBar(self)
self._ch1_rateIndex_tool_bar.addWidget(Qt.QLabel('Rate Index' + ": "))
self._ch1_rateIndex_combo_box = Qt.QComboBox()
self._ch1_rateIndex_tool_bar.addWidget(self._ch1_rateIndex_combo_box)
for label in self._ch1_rateIndex_labels:
self._ch1_rateIndex_combo_box.addItem(label)
self._ch1_rateIndex_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._ch1_rateIndex_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._ch1_rateIndex_options.index(i)))
self._ch1_rateIndex_callback(self.ch1_rateIndex)
self._ch1_rateIndex_combo_box.currentIndexChanged.connect(
lambda i: self.set_ch1_rateIndex(self._ch1_rateIndex_options[i]))
self.top_grid_layout.addWidget(self._ch1_rateIndex_tool_bar, 1, 1, 1,
1)
self._ch1_index_options = ch1_channelList
self._ch1_index_labels = map(str, self._ch1_index_options)
self._ch1_index_tool_bar = Qt.QToolBar(self)
self._ch1_index_tool_bar.addWidget(Qt.QLabel('WBDDC' + ": "))
self._ch1_index_combo_box = Qt.QComboBox()
self._ch1_index_tool_bar.addWidget(self._ch1_index_combo_box)
for label in self._ch1_index_labels:
self._ch1_index_combo_box.addItem(label)
self._ch1_index_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._ch1_index_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._ch1_index_options.index(i)))
self._ch1_index_callback(self.ch1_index)
self._ch1_index_combo_box.currentIndexChanged.connect(
lambda i: self.set_ch1_index(self._ch1_index_options[i]))
self.top_grid_layout.addWidget(self._ch1_index_tool_bar, 1, 0, 1, 1)
self._ch1_ddcFreq_range = Range(
radioClass.getWbddcFrequencyRange()[0] / 1e3,
radioClass.getWbddcFrequencyRange()[1] / 1e3, 10, 0, 200)
self._ch1_ddcFreq_win = RangeWidget(self._ch1_ddcFreq_range,
self.set_ch1_ddcFreq, 'Freq (kHz)',
"counter_slider", float)
self.top_grid_layout.addWidget(self._ch1_ddcFreq_win, 1,
fftColSpan / 2, 1, fftColSpan / 2)
self.ndrDemoControlBlock = CyberRadio.NDR_demo_control(
radio_type=str(radioType),
radio_hostname=str(hostnameOrDevice),
radio_port=int(udpPortOrBaudrate),
tuner1_index=ch1_index,
tuner1_freq=float(1e6 * ch1_rfFreq),
tuner1_atten=ch1_rfAtten,
tuner2_index=ch2_index if ch2_wb else -1,
tuner2_freq=float(1e6 * ch2_rfFreq),
tuner2_atten=ch2_rfAtten,
ddc1_index=ch1_index,
ddc1_wideband=True,
ddc1_enable=True,
ddc1_vita49_level=vitaLevel,
ddc1_rate_index=ch1_rateIndex,
ddc1_freq=ch1_ddcFreq * 1e3,
ddc1_udp_port=udpPortList[0],
ddc1_rf_source=-1,
ddc1_data_port=dataPort,
ddc2_index=ch2_index,
ddc2_wideband=ch2_wb,
ddc2_enable=True,
ddc2_vita49_level=vitaLevel,
ddc2_rate_index=ch2_rateIndex,
ddc2_freq=1e3 * ch2_ddcFreq,
ddc2_udp_port=udpPortList[1],
ddc2_rf_source=-1 if ch2_wb else ch1_index,
ddc2_data_port=dataPort,
cal_freq=0.0,
interface_dict={dataPort: str(ifname)},
verbose=bool(verbose),
other_args={})
self.ch2_tabs = Qt.QTabWidget()
self.ch2_tabs_widget_0 = Qt.QWidget()
self.ch2_tabs_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.ch2_tabs_widget_0)
self.ch2_tabs_grid_layout_0 = Qt.QGridLayout()
self.ch2_tabs_layout_0.addLayout(self.ch2_tabs_grid_layout_0)
self.ch2_tabs.addTab(self.ch2_tabs_widget_0, 'Spectrum')
self.ch2_tabs_widget_1 = Qt.QWidget()
self.ch2_tabs_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.ch2_tabs_widget_1)
self.ch2_tabs_grid_layout_1 = Qt.QGridLayout()
self.ch2_tabs_layout_1.addLayout(self.ch2_tabs_grid_layout_1)
self.ch2_tabs.addTab(self.ch2_tabs_widget_1, 'Time')
self.top_grid_layout.addWidget(self.ch2_tabs, 0, fftColSpan, 1,
fftColSpan)
self.ch1_tabs = Qt.QTabWidget()
self.ch1_tabs_widget_0 = Qt.QWidget()
self.ch1_tabs_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.ch1_tabs_widget_0)
self.ch1_tabs_grid_layout_0 = Qt.QGridLayout()
self.ch1_tabs_layout_0.addLayout(self.ch1_tabs_grid_layout_0)
self.ch1_tabs.addTab(self.ch1_tabs_widget_0, 'Spectrum')
self.ch1_tabs_widget_1 = Qt.QWidget()
self.ch1_tabs_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.ch1_tabs_widget_1)
self.ch1_tabs_grid_layout_1 = Qt.QGridLayout()
self.ch1_tabs_layout_1.addLayout(self.ch1_tabs_grid_layout_1)
self.ch1_tabs.addTab(self.ch1_tabs_widget_1, 'Waterfall')
self.top_grid_layout.addWidget(self.ch1_tabs, 0, 0, 1, fftColSpan)
self._radioRspDisplay_tool_bar = Qt.QToolBar(self)
self._radioRspDisplay_tool_bar.addWidget(
Qt.QLabel('Command Response' + ": "))
self._radioRspDisplay_line_edit = Qt.QLineEdit(
str(self.radioRspDisplay))
self._radioRspDisplay_tool_bar.addWidget(
self._radioRspDisplay_line_edit)
self._radioRspDisplay_line_edit.returnPressed.connect(
lambda: self.set_radioRspDisplay(
str(str(self._radioRspDisplay_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._radioRspDisplay_tool_bar, 3, 2, 1,
2 * fftColSpan - 2)
def _radioRsp_probe():
while True:
val = self.ndrDemoControlBlock.get_radio_rsp()
try:
self.set_radioRsp(val)
except AttributeError:
pass
time.sleep(1.0 / (10))
_radioRsp_thread = threading.Thread(target=_radioRsp_probe)
_radioRsp_thread.daemon = True
_radioRsp_thread.start()
self._radioCmd_tool_bar = Qt.QToolBar(self)
self._radioCmd_tool_bar.addWidget(Qt.QLabel('Manual Command' + ": "))
self._radioCmd_line_edit = Qt.QLineEdit(str(self.radioCmd))
self._radioCmd_tool_bar.addWidget(self._radioCmd_line_edit)
self._radioCmd_line_edit.returnPressed.connect(
lambda: self.set_radioCmd(
str(str(self._radioCmd_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._radioCmd_tool_bar, 3, 0, 1, 2)
self.qtgui_waterfall_sink_x_0 = qtgui.waterfall_sink_c(
ch1_fftSize, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
ch1_rfFreq * 1e6 + ch1_ddcFreq * 1e3, #fc
ch1_fs, #bw
'Ch 1 (Wideband)', #name
1 #number of inputs
)
self.qtgui_waterfall_sink_x_0.set_update_time(1.0 / ch1_updateRate)
self.qtgui_waterfall_sink_x_0.enable_grid(True)
self.qtgui_waterfall_sink_x_0.enable_axis_labels(True)
if not True:
self.qtgui_waterfall_sink_x_0.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.qtgui_waterfall_sink_x_0.set_plot_pos_half(not True)
labels = ['', '', '', '', '', '', '', '', '', '']
colors = [5, 0, 0, 0, 0, 0, 0, 0, 0, 0]
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_waterfall_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_waterfall_sink_x_0.set_line_label(i, labels[i])
self.qtgui_waterfall_sink_x_0.set_color_map(i, colors[i])
self.qtgui_waterfall_sink_x_0.set_line_alpha(i, alphas[i])
self.qtgui_waterfall_sink_x_0.set_intensity_range(-120, 0)
self._qtgui_waterfall_sink_x_0_win = sip.wrapinstance(
self.qtgui_waterfall_sink_x_0.pyqwidget(), Qt.QWidget)
self.ch1_tabs_layout_1.addWidget(self._qtgui_waterfall_sink_x_0_win)
self.qtgui_time_sink_x_0 = qtgui.time_sink_c(
1024, #size
ch2_fs, #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(True)
self.qtgui_time_sink_x_0.enable_grid(True)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(False)
if not False:
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.ch2_tabs_layout_1.addWidget(self._qtgui_time_sink_x_0_win)
self._ch2_fsLabel_tool_bar = Qt.QToolBar(self)
if None:
self._ch2_fsLabel_formatter = None
else:
self._ch2_fsLabel_formatter = lambda x: x
self._ch2_fsLabel_tool_bar.addWidget(Qt.QLabel('fs' + ": "))
self._ch2_fsLabel_label = Qt.QLabel(
str(self._ch2_fsLabel_formatter(self.ch2_fsLabel)))
self._ch2_fsLabel_tool_bar.addWidget(self._ch2_fsLabel_label)
self.top_grid_layout.addWidget(self._ch2_fsLabel_tool_bar, 1,
fftColSpan + 2, 1, 1)
self.ch2_fftDisplay = qtgui.freq_sink_c(
ch2_fftSize, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
(ch2_rfFreq if ch2_wb else ch1_rfFreq) * 1e6 +
ch2_ddcFreq * 1e3, #fc
ch2_fs, #bw
"Channel 2 (%sband)" % ("Wide" if ch2_wb else "Narrow"), #name
1 #number of inputs
)
self.ch2_fftDisplay.set_update_time(1.0 / ch2_updateRate)
self.ch2_fftDisplay.set_y_axis(-120, 0)
self.ch2_fftDisplay.set_y_label('Relative Gain', 'dB')
self.ch2_fftDisplay.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.ch2_fftDisplay.enable_autoscale(False)
self.ch2_fftDisplay.enable_grid(True)
self.ch2_fftDisplay.set_fft_average(0.2)
self.ch2_fftDisplay.enable_axis_labels(True)
self.ch2_fftDisplay.enable_control_panel(False)
if not False:
self.ch2_fftDisplay.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.ch2_fftDisplay.set_plot_pos_half(not True)
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"red", "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.ch2_fftDisplay.set_line_label(i, "Data {0}".format(i))
else:
self.ch2_fftDisplay.set_line_label(i, labels[i])
self.ch2_fftDisplay.set_line_width(i, widths[i])
self.ch2_fftDisplay.set_line_color(i, colors[i])
self.ch2_fftDisplay.set_line_alpha(i, alphas[i])
self._ch2_fftDisplay_win = sip.wrapinstance(
self.ch2_fftDisplay.pyqwidget(), Qt.QWidget)
self.ch2_tabs_layout_0.addWidget(self._ch2_fftDisplay_win)
self._ch1_fsLabel_tool_bar = Qt.QToolBar(self)
if None:
self._ch1_fsLabel_formatter = None
else:
self._ch1_fsLabel_formatter = lambda x: x
self._ch1_fsLabel_tool_bar.addWidget(Qt.QLabel('fs' + ": "))
self._ch1_fsLabel_label = Qt.QLabel(
str(self._ch1_fsLabel_formatter(self.ch1_fsLabel)))
self._ch1_fsLabel_tool_bar.addWidget(self._ch1_fsLabel_label)
self.top_grid_layout.addWidget(self._ch1_fsLabel_tool_bar, 1, 2, 1, 1)
self.ch1_fftDisplay = qtgui.freq_sink_c(
ch1_fftSize, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
ch1_rfFreq * 1e6 + ch1_ddcFreq * 1e3, #fc
ch1_fs, #bw
'Channel 1 (Wideband)', #name
1 #number of inputs
)
self.ch1_fftDisplay.set_update_time(1.0 / ch1_updateRate)
self.ch1_fftDisplay.set_y_axis(-120, 0)
self.ch1_fftDisplay.set_y_label('Relative Gain', 'dB')
self.ch1_fftDisplay.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.ch1_fftDisplay.enable_autoscale(False)
self.ch1_fftDisplay.enable_grid(True)
self.ch1_fftDisplay.set_fft_average(0.2)
self.ch1_fftDisplay.enable_axis_labels(True)
self.ch1_fftDisplay.enable_control_panel(False)
if not False:
self.ch1_fftDisplay.disable_legend()
if "complex" == "float" or "complex" == "msg_float":
self.ch1_fftDisplay.set_plot_pos_half(not True)
labels = ['', '', '', '', '', '', '', '', '', '']
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"red", "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.ch1_fftDisplay.set_line_label(i, "Data {0}".format(i))
else:
self.ch1_fftDisplay.set_line_label(i, labels[i])
self.ch1_fftDisplay.set_line_width(i, widths[i])
self.ch1_fftDisplay.set_line_color(i, colors[i])
self.ch1_fftDisplay.set_line_alpha(i, alphas[i])
self._ch1_fftDisplay_win = sip.wrapinstance(
self.ch1_fftDisplay.pyqwidget(), Qt.QWidget)
self.ch1_tabs_layout_0.addWidget(self._ch1_fftDisplay_win)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char * 1, logfile,
False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_file_descriptor_sink_0 = blocks.file_descriptor_sink(
gr.sizeof_char * 1, 1)
self.CyberRadio_vita_udp_rx_0_0 = CyberRadio.vita_udp_rx(
macAndIpList[1], udpPortList[1], radioClass.getVitaHeaderSize(),
radioClass.getVitaPayloadSize() / 4,
radioClass.getVitaHeaderSize() +
radioClass.getVitaPayloadSize() + radioClass.getVitaTailSize(),
radioClass.isByteswapped(), False, False, False)
self.CyberRadio_vita_udp_rx_0 = CyberRadio.vita_udp_rx(
macAndIpList[1], udpPortList[0], radioClass.getVitaHeaderSize(),
radioClass.getVitaPayloadSize() / 4,
radioClass.getVitaHeaderSize() +
radioClass.getVitaPayloadSize() + radioClass.getVitaTailSize(),
radioClass.isByteswapped(), False, False, False)
##################################################
# Connections
##################################################
self.connect((self.CyberRadio_vita_udp_rx_0, 0),
(self.ch1_fftDisplay, 0))
self.connect((self.CyberRadio_vita_udp_rx_0, 0),
(self.qtgui_waterfall_sink_x_0, 0))
self.connect((self.CyberRadio_vita_udp_rx_0_0, 0),
(self.ch2_fftDisplay, 0))
self.connect((self.CyberRadio_vita_udp_rx_0_0, 0),
(self.qtgui_time_sink_x_0, 0))
self.connect((self.ndrDemoControlBlock, 0),
(self.blocks_file_descriptor_sink_0, 0))
self.connect((self.ndrDemoControlBlock, 0),
(self.blocks_file_sink_0, 0))
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="NDR304 Example")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.wbddc1_tuner_freq_mhz = wbddc1_tuner_freq_mhz = 900
self.wbddc1_nominal_sample_rate = wbddc1_nominal_sample_rate = 32000
self.wbddc1_ddc_offset = wbddc1_ddc_offset = 0
##################################################
# Blocks
##################################################
self._wbddc1_tuner_freq_mhz_text_box = forms.text_box(
parent=self.GetWin(),
value=self.wbddc1_tuner_freq_mhz,
callback=self.set_wbddc1_tuner_freq_mhz,
label="WBDDC 1 Tuner Frequency (MHz)",
converter=forms.int_converter(),
)
self.Add(self._wbddc1_tuner_freq_mhz_text_box)
self._wbddc1_ddc_offset_text_box = forms.text_box(
parent=self.GetWin(),
value=self.wbddc1_ddc_offset,
callback=self.set_wbddc1_ddc_offset,
label="WBDDC 1 Frequency Offset (Hz)",
converter=forms.float_converter(),
)
self.Add(self._wbddc1_ddc_offset_text_box)
self.CyberRadio_NDR304_source_0 = CyberRadio.NDR304_source(
verbose_mode=True,
radio_device_name="/dev/ndr47x",
radio_baud_rate=921600,
gig_iface_to_use="eth0",
num_tuners=1,
tuner1_param_list=[True, wbddc1_tuner_freq_mhz * 1e6, 0],
num_wbddcs=1,
wbddc1_param_list=[40001, 0, 0, True, wbddc1_ddc_offset],
tagged=True,
)
def _wbddc1_nominal_sample_rate_probe():
while True:
val = self.CyberRadio_NDR304_source_0.get_wbddc_nominal_sample_rate(1)
try: self.set_wbddc1_nominal_sample_rate(val)
except AttributeError, e: pass
time.sleep(1.0/(10))
_wbddc1_nominal_sample_rate_thread = threading.Thread(target=_wbddc1_nominal_sample_rate_probe)
_wbddc1_nominal_sample_rate_thread.daemon = True
_wbddc1_nominal_sample_rate_thread.start()
self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
self.GetWin(),
baseband_freq=wbddc1_tuner_freq_mhz * 1e6 + wbddc1_ddc_offset,
y_per_div=10,
y_divs=12,
ref_level=0,
ref_scale=2,
sample_rate=wbddc1_nominal_sample_rate,
fft_size=1024,
fft_rate=15,
average=False,
avg_alpha=None,
title="FFT Plot",
peak_hold=False,
)
self.Add(self.wxgui_fftsink2_0.win)
self.blocks_file_descriptor_sink_0 = blocks.file_descriptor_sink(gr.sizeof_char*1, 2)
##################################################
# Connections
##################################################
self.connect((self.CyberRadio_NDR304_source_0, 0), (self.blocks_file_descriptor_sink_0, 0))
self.connect((self.CyberRadio_NDR304_source_0, 1), (self.wxgui_fftsink2_0, 0))
def __init__(self, num_ch, file_name, sensorLoc, sensorSys, sensor_id,
sensor_key, center_freq, bandwidth, meas_duration, atten,
samp_rate, avoid_LO):
gr.sync_block.__init__(self,
name="jsonfile_sink",
in_sig=[(bytes, num_ch)],
out_sig=None)
# Establish ssl socket connection to server
self.num_ch = num_ch
# Open file for output stream
self.file_name = file_name
self.f = open(self.file_name, 'wb')
self.srvr = blocks.file_descriptor_sink(self.num_ch * gr.sizeof_char,
self.f.fileno())
self.sensorLoc = sensorLoc
self.sensorSys = sensorSys
self.sensor_id = sensor_id
self.sensor_key = sensor_key
self.center_freq = center_freq
self.bandwidth = bandwidth
self.meas_duration = meas_duration
self.atten = atten
self.samp_rate = samp_rate
self.avoid = avoid_LO
print("Sensor ID: ", self.sensor_id)
# Send location and system info to server
loc_msg = self.read_json_from_file(self.sensorLoc)
sys_msg = self.read_json_from_file(self.sensorSys)
ts = long(round(getLocalUtcTimeStamp()))
print 'Serial no.', self.sensor_id
loc_msg['t'] = ts
loc_msg['SensorID'] = self.sensor_id
sys_msg['t'] = ts
sys_msg['SensorID'] = self.sensor_id
self.post_msg(loc_msg)
self.post_msg(sys_msg)
# Form data header
ts = long(round(getLocalUtcTimeStamp()))
f_start = self.center_freq - self.bandwidth / 2.0
if self.avoid:
#self.center_freq = self.center_freq + self.samp_rate/4.0
#print "Avoiding LO...\nShifting center Frequency to", self.center_freq
f_start = (self.center_freq -
self.samp_rate / 4) - self.bandwidth / 2.0
f_stop = f_start + self.bandwidth
if self.avoid:
print "Avoiding LO, frequencies are shifted to: [", f_start / 1e6, "MHz-", f_stop / 1e6, "MHz ]"
mpar = Struct(fStart=f_start,
fStop=f_stop,
n=self.num_ch,
td=-1,
tm=self.meas_duration,
Det='Average',
Atten=self.atten)
# Need to add a field for overflow indicator
data_hdr = Struct(
Ver='1.0.12',
Type='Data',
SensorID=self.sensor_id,
SensorKey=self.sensor_key,
t=ts,
Sys2Detect='LTE',
Sensitivity='Low',
mType='FFT-Power',
t1=ts,
a=1,
nM=-1,
Ta=-1,
OL='NaN',
wnI=-77.0,
Comment=
'Using hard-coded (not detected) system noise power for wnI',
Processed='False',
DataType='Binary - int8',
ByteOrder='N/A',
Compression='None',
mPar=mpar)
self.post_msg(data_hdr)
self.f.flush()
date_str = formatTimeStampLong(ts, loc_msg['TimeZone'])
print date_str, "fc =", self.center_freq / 1e6, "MHz. Writing data to file", self.file_name
def __init__(self):
gr.top_block.__init__(self, "NDR651 Sink Demo")
Qt.QWidget.__init__(self)
self.setWindowTitle("NDR651 Sink Demo")
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", "ndr651_sink_demo")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.wbduc2_stream = wbduc2_stream = 42002
self.wbduc2_rate = wbduc2_rate = 0
self.wbduc2_nominal_sample_rate = wbduc2_nominal_sample_rate = 32000
self.wbduc2_iface = wbduc2_iface = "eth10"
self.wbduc2_freq = wbduc2_freq = 0
self.wbduc2_chans = wbduc2_chans = 2
self.wbduc2_atten = wbduc2_atten = 0
self.wbduc1_stream = wbduc1_stream = 42001
self.wbduc1_rate = wbduc1_rate = 0
self.wbduc1_nominal_sample_rate = wbduc1_nominal_sample_rate = 32000
self.wbduc1_iface = wbduc1_iface = "eth10"
self.wbduc1_freq = wbduc1_freq = 0
self.wbduc1_chans = wbduc1_chans = 1
self.wbduc1_atten = wbduc1_atten = 0
self.tx2_freq = tx2_freq = 901
self.tx2_enable = tx2_enable = True
self.tx2_atten = tx2_atten = 2
self.tx1_freq = tx1_freq = 899
self.tx1_enable = tx1_enable = True
self.tx1_atten = tx1_atten = 1
##################################################
# Blocks
##################################################
self._wbduc2_stream_tool_bar = Qt.QToolBar(self)
self._wbduc2_stream_tool_bar.addWidget(Qt.QLabel("Stream"+": "))
self._wbduc2_stream_line_edit = Qt.QLineEdit(str(self.wbduc2_stream))
self._wbduc2_stream_tool_bar.addWidget(self._wbduc2_stream_line_edit)
self._wbduc2_stream_line_edit.returnPressed.connect(
lambda: self.set_wbduc2_stream(int(str(self._wbduc2_stream_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc2_stream_tool_bar, 3, 5, 1, 1)
self._wbduc2_rate_tool_bar = Qt.QToolBar(self)
self._wbduc2_rate_tool_bar.addWidget(Qt.QLabel("Rate"+": "))
self._wbduc2_rate_line_edit = Qt.QLineEdit(str(self.wbduc2_rate))
self._wbduc2_rate_tool_bar.addWidget(self._wbduc2_rate_line_edit)
self._wbduc2_rate_line_edit.returnPressed.connect(
lambda: self.set_wbduc2_rate(int(str(self._wbduc2_rate_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc2_rate_tool_bar, 3, 1, 1, 1)
self._wbduc2_iface_tool_bar = Qt.QToolBar(self)
self._wbduc2_iface_tool_bar.addWidget(Qt.QLabel("DUC2: IFace"+": "))
self._wbduc2_iface_line_edit = Qt.QLineEdit(str(self.wbduc2_iface))
self._wbduc2_iface_tool_bar.addWidget(self._wbduc2_iface_line_edit)
self._wbduc2_iface_line_edit.returnPressed.connect(
lambda: self.set_wbduc2_iface(str(str(self._wbduc2_iface_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc2_iface_tool_bar, 3, 0, 1, 1)
self._wbduc2_freq_tool_bar = Qt.QToolBar(self)
self._wbduc2_freq_tool_bar.addWidget(Qt.QLabel("Freq"+": "))
self._wbduc2_freq_line_edit = Qt.QLineEdit(str(self.wbduc2_freq))
self._wbduc2_freq_tool_bar.addWidget(self._wbduc2_freq_line_edit)
self._wbduc2_freq_line_edit.returnPressed.connect(
lambda: self.set_wbduc2_freq(int(str(self._wbduc2_freq_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc2_freq_tool_bar, 3, 2, 1, 1)
self._wbduc2_chans_tool_bar = Qt.QToolBar(self)
self._wbduc2_chans_tool_bar.addWidget(Qt.QLabel("Chans"+": "))
self._wbduc2_chans_line_edit = Qt.QLineEdit(str(self.wbduc2_chans))
self._wbduc2_chans_tool_bar.addWidget(self._wbduc2_chans_line_edit)
self._wbduc2_chans_line_edit.returnPressed.connect(
lambda: self.set_wbduc2_chans(int(str(self._wbduc2_chans_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc2_chans_tool_bar, 3, 4, 1, 1)
self._wbduc2_atten_tool_bar = Qt.QToolBar(self)
self._wbduc2_atten_tool_bar.addWidget(Qt.QLabel("Atten"+": "))
self._wbduc2_atten_line_edit = Qt.QLineEdit(str(self.wbduc2_atten))
self._wbduc2_atten_tool_bar.addWidget(self._wbduc2_atten_line_edit)
self._wbduc2_atten_line_edit.returnPressed.connect(
lambda: self.set_wbduc2_atten(int(str(self._wbduc2_atten_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc2_atten_tool_bar, 3, 3, 1, 1)
self._wbduc1_stream_tool_bar = Qt.QToolBar(self)
self._wbduc1_stream_tool_bar.addWidget(Qt.QLabel("Stream"+": "))
self._wbduc1_stream_line_edit = Qt.QLineEdit(str(self.wbduc1_stream))
self._wbduc1_stream_tool_bar.addWidget(self._wbduc1_stream_line_edit)
self._wbduc1_stream_line_edit.returnPressed.connect(
lambda: self.set_wbduc1_stream(int(str(self._wbduc1_stream_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc1_stream_tool_bar, 2, 5, 1, 1)
self._wbduc1_rate_tool_bar = Qt.QToolBar(self)
self._wbduc1_rate_tool_bar.addWidget(Qt.QLabel("Rate"+": "))
self._wbduc1_rate_line_edit = Qt.QLineEdit(str(self.wbduc1_rate))
self._wbduc1_rate_tool_bar.addWidget(self._wbduc1_rate_line_edit)
self._wbduc1_rate_line_edit.returnPressed.connect(
lambda: self.set_wbduc1_rate(int(str(self._wbduc1_rate_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc1_rate_tool_bar, 2, 1, 1, 1)
self._wbduc1_iface_tool_bar = Qt.QToolBar(self)
self._wbduc1_iface_tool_bar.addWidget(Qt.QLabel("DUC1: IFace"+": "))
self._wbduc1_iface_line_edit = Qt.QLineEdit(str(self.wbduc1_iface))
self._wbduc1_iface_tool_bar.addWidget(self._wbduc1_iface_line_edit)
self._wbduc1_iface_line_edit.returnPressed.connect(
lambda: self.set_wbduc1_iface(str(str(self._wbduc1_iface_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc1_iface_tool_bar, 2, 0, 1, 1)
self._wbduc1_freq_tool_bar = Qt.QToolBar(self)
self._wbduc1_freq_tool_bar.addWidget(Qt.QLabel("Freq"+": "))
self._wbduc1_freq_line_edit = Qt.QLineEdit(str(self.wbduc1_freq))
self._wbduc1_freq_tool_bar.addWidget(self._wbduc1_freq_line_edit)
self._wbduc1_freq_line_edit.returnPressed.connect(
lambda: self.set_wbduc1_freq(int(str(self._wbduc1_freq_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc1_freq_tool_bar, 2, 2, 1, 1)
self._wbduc1_chans_tool_bar = Qt.QToolBar(self)
self._wbduc1_chans_tool_bar.addWidget(Qt.QLabel("Chans"+": "))
self._wbduc1_chans_line_edit = Qt.QLineEdit(str(self.wbduc1_chans))
self._wbduc1_chans_tool_bar.addWidget(self._wbduc1_chans_line_edit)
self._wbduc1_chans_line_edit.returnPressed.connect(
lambda: self.set_wbduc1_chans(int(str(self._wbduc1_chans_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc1_chans_tool_bar, 2, 4, 1, 1)
self._wbduc1_atten_tool_bar = Qt.QToolBar(self)
self._wbduc1_atten_tool_bar.addWidget(Qt.QLabel("Atten"+": "))
self._wbduc1_atten_line_edit = Qt.QLineEdit(str(self.wbduc1_atten))
self._wbduc1_atten_tool_bar.addWidget(self._wbduc1_atten_line_edit)
self._wbduc1_atten_line_edit.returnPressed.connect(
lambda: self.set_wbduc1_atten(int(str(self._wbduc1_atten_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbduc1_atten_tool_bar, 2, 3, 1, 1)
self._tx2_freq_tool_bar = Qt.QToolBar(self)
self._tx2_freq_tool_bar.addWidget(Qt.QLabel("Freq"+": "))
self._tx2_freq_line_edit = Qt.QLineEdit(str(self.tx2_freq))
self._tx2_freq_tool_bar.addWidget(self._tx2_freq_line_edit)
self._tx2_freq_line_edit.returnPressed.connect(
lambda: self.set_tx2_freq(int(str(self._tx2_freq_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._tx2_freq_tool_bar, 1, 1, 1, 1)
_tx2_enable_check_box = Qt.QCheckBox("TX2: Enable")
self._tx2_enable_choices = {True: True, False: False}
self._tx2_enable_choices_inv = dict((v,k) for k,v in self._tx2_enable_choices.iteritems())
self._tx2_enable_callback = lambda i: Qt.QMetaObject.invokeMethod(_tx2_enable_check_box, "setChecked", Qt.Q_ARG("bool", self._tx2_enable_choices_inv[i]))
self._tx2_enable_callback(self.tx2_enable)
_tx2_enable_check_box.stateChanged.connect(lambda i: self.set_tx2_enable(self._tx2_enable_choices[bool(i)]))
self.top_grid_layout.addWidget(_tx2_enable_check_box, 1, 0, 1, 1)
self._tx2_atten_tool_bar = Qt.QToolBar(self)
self._tx2_atten_tool_bar.addWidget(Qt.QLabel("Atten"+": "))
self._tx2_atten_line_edit = Qt.QLineEdit(str(self.tx2_atten))
self._tx2_atten_tool_bar.addWidget(self._tx2_atten_line_edit)
self._tx2_atten_line_edit.returnPressed.connect(
lambda: self.set_tx2_atten(int(str(self._tx2_atten_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._tx2_atten_tool_bar, 1, 2, 1, 1)
self._tx1_freq_tool_bar = Qt.QToolBar(self)
self._tx1_freq_tool_bar.addWidget(Qt.QLabel("Freq"+": "))
self._tx1_freq_line_edit = Qt.QLineEdit(str(self.tx1_freq))
self._tx1_freq_tool_bar.addWidget(self._tx1_freq_line_edit)
self._tx1_freq_line_edit.returnPressed.connect(
lambda: self.set_tx1_freq(int(str(self._tx1_freq_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._tx1_freq_tool_bar, 0, 1, 1, 1)
_tx1_enable_check_box = Qt.QCheckBox("TX1: Enable")
self._tx1_enable_choices = {True: True, False: False}
self._tx1_enable_choices_inv = dict((v,k) for k,v in self._tx1_enable_choices.iteritems())
self._tx1_enable_callback = lambda i: Qt.QMetaObject.invokeMethod(_tx1_enable_check_box, "setChecked", Qt.Q_ARG("bool", self._tx1_enable_choices_inv[i]))
self._tx1_enable_callback(self.tx1_enable)
_tx1_enable_check_box.stateChanged.connect(lambda i: self.set_tx1_enable(self._tx1_enable_choices[bool(i)]))
self.top_grid_layout.addWidget(_tx1_enable_check_box, 0, 0, 1, 1)
self._tx1_atten_tool_bar = Qt.QToolBar(self)
self._tx1_atten_tool_bar.addWidget(Qt.QLabel("Atten"+": "))
self._tx1_atten_line_edit = Qt.QLineEdit(str(self.tx1_atten))
self._tx1_atten_tool_bar.addWidget(self._tx1_atten_line_edit)
self._tx1_atten_line_edit.returnPressed.connect(
lambda: self.set_tx1_atten(int(str(self._tx1_atten_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._tx1_atten_tool_bar, 0, 2, 1, 1)
self.CyberRadio_NDR651_sink_0 = CyberRadio.NDR651_sink(
verbose_mode=True,
radio_host_name="ndr651",
radio_host_port=8617,
tengig_iface_list=['eth10', 'eth11'],
iq_scale_factor=2**15,
num_transmitters=2,
transmitter1_param_list=[tx1_enable, tx1_freq, tx1_atten],
transmitter2_param_list=[tx2_enable, tx2_freq, tx2_atten],
num_wbducs=2,
wbduc1_param_list=[wbduc1_iface, wbduc1_rate, wbduc1_freq, wbduc1_atten, wbduc1_chans, wbduc1_stream],
wbduc2_param_list=[wbduc2_iface, wbduc2_rate, wbduc2_freq, wbduc2_atten, wbduc2_chans, wbduc2_stream],
debug=False,
)
def _wbduc2_nominal_sample_rate_probe():
while True:
val = self.CyberRadio_NDR651_sink_0.get_wbduc_nominal_sample_rate(2)
try: self.set_wbduc2_nominal_sample_rate(val)
except AttributeError, e: pass
time.sleep(1.0/(2))
_wbduc2_nominal_sample_rate_thread = threading.Thread(target=_wbduc2_nominal_sample_rate_probe)
_wbduc2_nominal_sample_rate_thread.daemon = True
_wbduc2_nominal_sample_rate_thread.start()
def _wbduc1_nominal_sample_rate_probe():
while True:
val = self.CyberRadio_NDR651_sink_0.get_wbduc_nominal_sample_rate(1)
try: self.set_wbduc1_nominal_sample_rate(val)
except AttributeError, e: pass
time.sleep(1.0/(2))
_wbduc1_nominal_sample_rate_thread = threading.Thread(target=_wbduc1_nominal_sample_rate_probe)
_wbduc1_nominal_sample_rate_thread.daemon = True
_wbduc1_nominal_sample_rate_thread.start()
self.blocks_file_descriptor_sink_1 = blocks.file_descriptor_sink(gr.sizeof_char*1, 2)
self.analog_sig_source_x_1 = analog.sig_source_c(wbduc2_nominal_sample_rate, analog.GR_SQR_WAVE, 1e6, 1, 0)
self.analog_sig_source_x_0 = analog.sig_source_c(wbduc1_nominal_sample_rate, analog.GR_SQR_WAVE, 1e6, 1, 0)
##################################################
# Connections
##################################################
self.connect((self.CyberRadio_NDR651_sink_0, 0), (self.blocks_file_descriptor_sink_1, 0))
self.connect((self.analog_sig_source_x_0, 0), (self.CyberRadio_NDR651_sink_0, 0))
self.connect((self.analog_sig_source_x_1, 0), (self.CyberRadio_NDR651_sink_0, 1))
def __init__(self):
gr.top_block.__init__(self, "NDR308 Source Demo")
Qt.QWidget.__init__(self)
self.setWindowTitle("NDR308 Source Demo")
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", "CyberRadio_NDR308_source")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.wbddc2_rate = wbddc2_rate = 0
self.wbddc2_nominal_sample_rate = wbddc2_nominal_sample_rate = 32000
self.wbddc2_enable = wbddc2_enable = True
self.wbddc1_rate = wbddc1_rate = 0
self.wbddc1_nominal_sample_rate = wbddc1_nominal_sample_rate = 32000
self.wbddc1_enable = wbddc1_enable = True
self.tuner2_freq = tuner2_freq = 900
self.tuner2_enable = tuner2_enable = True
self.tuner2_atten = tuner2_atten = 0
self.tuner1_freq = tuner1_freq = 900
self.tuner1_enable = tuner1_enable = True
self.tuner1_atten = tuner1_atten = 0
##################################################
# Blocks
##################################################
self._wbddc2_rate_tool_bar = Qt.QToolBar(self)
self._wbddc2_rate_tool_bar.addWidget(Qt.QLabel("WBDDC 2: Rate"+": "))
self._wbddc2_rate_line_edit = Qt.QLineEdit(str(self.wbddc2_rate))
self._wbddc2_rate_tool_bar.addWidget(self._wbddc2_rate_line_edit)
self._wbddc2_rate_line_edit.returnPressed.connect(
lambda: self.set_wbddc2_rate(int(str(self._wbddc2_rate_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbddc2_rate_tool_bar, 3, 0, 1, 1)
_wbddc2_enable_check_box = Qt.QCheckBox("Enabled")
self._wbddc2_enable_choices = {True: True, False: False}
self._wbddc2_enable_choices_inv = dict((v,k) for k,v in self._wbddc2_enable_choices.iteritems())
self._wbddc2_enable_callback = lambda i: Qt.QMetaObject.invokeMethod(_wbddc2_enable_check_box, "setChecked", Qt.Q_ARG("bool", self._wbddc2_enable_choices_inv[i]))
self._wbddc2_enable_callback(self.wbddc2_enable)
_wbddc2_enable_check_box.stateChanged.connect(lambda i: self.set_wbddc2_enable(self._wbddc2_enable_choices[bool(i)]))
self.top_grid_layout.addWidget(_wbddc2_enable_check_box, 3, 1, 1, 1)
self._wbddc1_rate_tool_bar = Qt.QToolBar(self)
self._wbddc1_rate_tool_bar.addWidget(Qt.QLabel("WBDDC 1: Rate"+": "))
self._wbddc1_rate_line_edit = Qt.QLineEdit(str(self.wbddc1_rate))
self._wbddc1_rate_tool_bar.addWidget(self._wbddc1_rate_line_edit)
self._wbddc1_rate_line_edit.returnPressed.connect(
lambda: self.set_wbddc1_rate(int(str(self._wbddc1_rate_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._wbddc1_rate_tool_bar, 2, 0, 1, 1)
_wbddc1_enable_check_box = Qt.QCheckBox("Enabled")
self._wbddc1_enable_choices = {True: True, False: False}
self._wbddc1_enable_choices_inv = dict((v,k) for k,v in self._wbddc1_enable_choices.iteritems())
self._wbddc1_enable_callback = lambda i: Qt.QMetaObject.invokeMethod(_wbddc1_enable_check_box, "setChecked", Qt.Q_ARG("bool", self._wbddc1_enable_choices_inv[i]))
self._wbddc1_enable_callback(self.wbddc1_enable)
_wbddc1_enable_check_box.stateChanged.connect(lambda i: self.set_wbddc1_enable(self._wbddc1_enable_choices[bool(i)]))
self.top_grid_layout.addWidget(_wbddc1_enable_check_box, 2, 1, 1, 1)
self._tuner2_freq_tool_bar = Qt.QToolBar(self)
self._tuner2_freq_tool_bar.addWidget(Qt.QLabel("Freq"+": "))
self._tuner2_freq_line_edit = Qt.QLineEdit(str(self.tuner2_freq))
self._tuner2_freq_tool_bar.addWidget(self._tuner2_freq_line_edit)
self._tuner2_freq_line_edit.returnPressed.connect(
lambda: self.set_tuner2_freq(int(str(self._tuner2_freq_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._tuner2_freq_tool_bar, 1, 1, 1, 1)
_tuner2_enable_check_box = Qt.QCheckBox("Tuner 2: Enable")
self._tuner2_enable_choices = {True: True, False: False}
self._tuner2_enable_choices_inv = dict((v,k) for k,v in self._tuner2_enable_choices.iteritems())
self._tuner2_enable_callback = lambda i: Qt.QMetaObject.invokeMethod(_tuner2_enable_check_box, "setChecked", Qt.Q_ARG("bool", self._tuner2_enable_choices_inv[i]))
self._tuner2_enable_callback(self.tuner2_enable)
_tuner2_enable_check_box.stateChanged.connect(lambda i: self.set_tuner2_enable(self._tuner2_enable_choices[bool(i)]))
self.top_grid_layout.addWidget(_tuner2_enable_check_box, 1, 0, 1, 1)
self._tuner2_atten_tool_bar = Qt.QToolBar(self)
self._tuner2_atten_tool_bar.addWidget(Qt.QLabel("Atten"+": "))
self._tuner2_atten_line_edit = Qt.QLineEdit(str(self.tuner2_atten))
self._tuner2_atten_tool_bar.addWidget(self._tuner2_atten_line_edit)
self._tuner2_atten_line_edit.returnPressed.connect(
lambda: self.set_tuner2_atten(int(str(self._tuner2_atten_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._tuner2_atten_tool_bar, 1, 2, 1, 1)
self._tuner1_freq_tool_bar = Qt.QToolBar(self)
self._tuner1_freq_tool_bar.addWidget(Qt.QLabel("Freq"+": "))
self._tuner1_freq_line_edit = Qt.QLineEdit(str(self.tuner1_freq))
self._tuner1_freq_tool_bar.addWidget(self._tuner1_freq_line_edit)
self._tuner1_freq_line_edit.returnPressed.connect(
lambda: self.set_tuner1_freq(int(str(self._tuner1_freq_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._tuner1_freq_tool_bar, 0, 1, 1, 1)
_tuner1_enable_check_box = Qt.QCheckBox("Tuner 1: Enable")
self._tuner1_enable_choices = {True: True, False: False}
self._tuner1_enable_choices_inv = dict((v,k) for k,v in self._tuner1_enable_choices.iteritems())
self._tuner1_enable_callback = lambda i: Qt.QMetaObject.invokeMethod(_tuner1_enable_check_box, "setChecked", Qt.Q_ARG("bool", self._tuner1_enable_choices_inv[i]))
self._tuner1_enable_callback(self.tuner1_enable)
_tuner1_enable_check_box.stateChanged.connect(lambda i: self.set_tuner1_enable(self._tuner1_enable_choices[bool(i)]))
self.top_grid_layout.addWidget(_tuner1_enable_check_box, 0, 0, 1, 1)
self._tuner1_atten_tool_bar = Qt.QToolBar(self)
self._tuner1_atten_tool_bar.addWidget(Qt.QLabel("Atten"+": "))
self._tuner1_atten_line_edit = Qt.QLineEdit(str(self.tuner1_atten))
self._tuner1_atten_tool_bar.addWidget(self._tuner1_atten_line_edit)
self._tuner1_atten_line_edit.returnPressed.connect(
lambda: self.set_tuner1_atten(int(str(self._tuner1_atten_line_edit.text().toAscii()))))
self.top_grid_layout.addWidget(self._tuner1_atten_tool_bar, 0, 2, 1, 1)
self.CyberRadio_NDR308_source_0 = CyberRadio.NDR308_source(
verbose_mode=True,
radio_host_name="ndr651",
radio_host_port=8617,
tengig_iface_list=['eth10', 'eth11'],
num_tuners=2,
tuner1_param_list=[tuner1_enable, tuner1_freq * 1e6, tuner1_atten],
tuner2_param_list=[tuner2_enable, tuner2_freq * 1e6, tuner2_atten],
num_wbddcs=2,
wbddc1_param_list=["eth10", 40001, 1, wbddc1_rate, wbddc1_enable],
wbddc2_param_list=["eth10", 40002, 1, wbddc2_rate, wbddc2_enable],
num_nbddcs=1,
nbddc1_param_list=["eth10", 41001, 0, 0, False, 0.0],
tagged=False,
debug=False,
)
def _wbddc1_nominal_sample_rate_probe():
while True:
val = self.CyberRadio_NDR308_source_0.get_wbddc_nominal_sample_rate(1)
try: self.set_wbddc1_nominal_sample_rate(val)
except AttributeError, e: pass
time.sleep(1.0/(2))
_wbddc1_nominal_sample_rate_thread = threading.Thread(target=_wbddc1_nominal_sample_rate_probe)
_wbddc1_nominal_sample_rate_thread.daemon = True
_wbddc1_nominal_sample_rate_thread.start()
def _wbddc2_nominal_sample_rate_probe():
while True:
val = self.CyberRadio_NDR308_source_0.get_wbddc_nominal_sample_rate(2)
try: self.set_wbddc2_nominal_sample_rate(val)
except AttributeError, e: pass
time.sleep(1.0/(2))
_wbddc2_nominal_sample_rate_thread = threading.Thread(target=_wbddc2_nominal_sample_rate_probe)
_wbddc2_nominal_sample_rate_thread.daemon = True
_wbddc2_nominal_sample_rate_thread.start()
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c(
1024, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
900e6, #fc
wbddc1_nominal_sample_rate, #bw
"", #name
2 #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_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(True)
self.qtgui_freq_sink_x_0.set_fft_average(0.2)
self.qtgui_freq_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_freq_sink_x_0.disable_legend()
if complex == type(float()):
self.qtgui_freq_sink_x_0.set_plot_pos_half(not True)
labels = ["WBDDC 1", "WBDDC 2", "", "", "",
"", "", "", "", ""]
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(2):
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.blocks_file_descriptor_sink_0 = blocks.file_descriptor_sink(gr.sizeof_char*1, 2)
##################################################
# Connections
##################################################
self.connect((self.CyberRadio_NDR308_source_0, 0), (self.blocks_file_descriptor_sink_0, 0))
self.connect((self.CyberRadio_NDR308_source_0, 1), (self.qtgui_freq_sink_x_0, 0))
self.connect((self.CyberRadio_NDR308_source_0, 2), (self.qtgui_freq_sink_x_0, 1))
def make_sink_to_process_stdin(process, itemsize=gr.sizeof_char):
"""Given a twisted Process, connect a sink to its stdin."""
fd_owned_by_twisted = process.pipes[0].fileno() # TODO: More public way to do this?
fd_owned_by_sink = os.dup(fd_owned_by_twisted)
process.closeStdin()
return blocks.file_descriptor_sink(itemsize, fd_owned_by_sink)
def __init__(self, input_file, output_file):
gr.top_block.__init__(self)
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 2048000
##################################################
# Blocks
##################################################
self.low_pass_filter_1 = filter.fir_filter_fff(
1,
firdes.low_pass(1, samp_rate, 85000, 2000, firdes.WIN_HAMMING,
6.76))
self.low_pass_filter_0 = filter.fir_filter_ccf(
1,
firdes.low_pass(1, samp_rate, 200000, 1000, firdes.WIN_HAMMING,
6.76))
if input_file != None:
self.blocks_wavfile_source_0 = blocks.wavfile_source(
input_file, False)
else:
import osmosdr
self.rtlsdr_source_0 = osmosdr.source(args="numchan=" + str(1) +
" " + "")
self.rtlsdr_source_0.set_sample_rate(samp_rate)
self.rtlsdr_source_0.set_center_freq(433463000, 0)
self.rtlsdr_source_0.set_freq_corr(0, 0)
self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
self.rtlsdr_source_0.set_iq_balance_mode(0, 0)
self.rtlsdr_source_0.set_gain_mode(False, 0)
self.rtlsdr_source_0.set_gain(10, 0)
self.rtlsdr_source_0.set_if_gain(20, 0)
self.rtlsdr_source_0.set_bb_gain(20, 0)
self.rtlsdr_source_0.set_antenna("", 0)
self.rtlsdr_source_0.set_bandwidth(0, 0)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_float_to_complex_0 = blocks.float_to_complex(1)
if output_file == '-':
self.blocks_file_sink_0 = blocks.file_descriptor_sink(4, 1)
else:
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float * 1,
output_file, False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_add_const_vxx_0 = blocks.add_const_vff((0.00, ))
self.analog_sig_source_x_0 = analog.sig_source_c(
samp_rate, analog.GR_COS_WAVE, -420000, 1, 0)
self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf(1)
##################################################
# Connections
##################################################
self.connect((self.analog_quadrature_demod_cf_0, 0),
(self.low_pass_filter_1, 0))
self.connect((self.analog_sig_source_x_0, 0),
(self.blocks_multiply_xx_0, 1))
self.connect((self.blocks_add_const_vxx_0, 0),
(self.blocks_file_sink_0, 0))
self.connect((self.blocks_multiply_xx_0, 0),
(self.low_pass_filter_0, 0))
self.connect((self.low_pass_filter_0, 0),
(self.analog_quadrature_demod_cf_0, 0))
self.connect((self.low_pass_filter_1, 0),
(self.blocks_add_const_vxx_0, 0))
if input_file != None:
self.connect((self.blocks_wavfile_source_0, 1),
(self.blocks_float_to_complex_0, 0))
self.connect((self.blocks_wavfile_source_0, 0),
(self.blocks_float_to_complex_0, 1))
self.connect((self.blocks_float_to_complex_0, 0),
(self.blocks_multiply_xx_0, 0))
else:
self.connect((self.rtlsdr_source_0, 0),
(self.blocks_multiply_xx_0, 0))
