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 __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, 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))