def test_001(self): port = 65500 n_data = 16 src_data = [float(x) for x in range(n_data)] expected_result = tuple(src_data) src = gr.vector_source_f(src_data) udp_snd = gr.udp_sink( gr.sizeof_float, 'localhost', port ) self.tb_snd.connect( src, udp_snd ) udp_rcv = gr.udp_source( gr.sizeof_float, 'localhost', port ) dst = gr.vector_sink_f() self.tb_rcv.connect( udp_rcv, dst ) self.tb_rcv.start() self.tb_snd.run() udp_snd.disconnect() self.timeout = False q = Timer(3.0,self.stop_rcv) q.start() self.tb_rcv.wait() q.cancel() result_data = dst.data() self.assertEqual(expected_result, result_data) self.assert_(not self.timeout)
def __init__(self, serverip, serverport, clientname, packetsize, simulation, samp_rate, center_freq, net_id, device_addr, stream_args): gr.hier_block2.__init__(self, "sim_source_c", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, gr.sizeof_gr_complex)) uhd_gate.__init__(self) self.simulation = simulation self.serverip = serverip self.samp_rate = samp_rate self.typ = 'rx' if not self.simulation: self.usrp = uhd.usrp_source(device_addr, stream_args) # TODO: Parameters self.connect(self.usrp, self) else: self.simsrc = sim_source_cc(self, serverip, serverport, clientname, packetsize, samp_rate, center_freq, net_id) # TODO: dirty hack!!! # self.tcp_source = grc_blks2.tcp_source(itemsize=gr.sizeof_gr_complex, # addr=self.serverip, # port=self.simsrc.get_dataport(), # server=False) self.tcp_source = gr.udp_source(itemsize=gr.sizeof_gr_complex, host=self.serverip, port=self.simsrc.get_dataport(), payload_size=1472, eof=False, wait=True) self.gain_blk = blocks.multiply_const_vcc((1, )) self.connect(self.tcp_source, self.gain_blk, self.simsrc, self)
def __init__(self, host, port, pkt_size, eof, wait): gr.top_block.__init__(self, "vector_sink") udp = gr.udp_source(gr.sizeof_float, host, port, pkt_size, eof=eof, wait=wait) sink = gr.file_sink(gr.sizeof_float, "received.dat") self.connect(udp, sink)
def test_002(self): udp_rcv = gr.udp_source( gr.sizeof_float, '0.0.0.0', 0, eof=False ) rcv_port = udp_rcv.get_port() udp_snd = gr.udp_sink( gr.sizeof_float, '127.0.0.1', 65500 ) udp_snd.connect( 'localhost', rcv_port ) n_data = 16 src_data = [float(x) for x in range(n_data)] expected_result = tuple(src_data) src = gr.vector_source_f(src_data) dst = gr.vector_sink_f() self.tb_snd.connect( src, udp_snd ) self.tb_rcv.connect( udp_rcv, dst ) self.tb_rcv.start() self.tb_snd.run() udp_snd.disconnect() self.timeout = False q = Timer(3.0,self.stop_rcv) q.start() self.tb_rcv.wait() q.cancel() result_data = dst.data() self.assertEqual(expected_result, result_data) self.assert_(self.timeout) # source ignores EOF?
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.wxgui_scopesink2_0 = scopesink2.scope_sink_f( self.GetWin(), title="Scope Plot", sample_rate=125, v_scale=0, v_offset=0, t_scale=1000, ac_couple=False, xy_mode=False, num_inputs=1, trig_mode=gr.gr_TRIG_MODE_AUTO, y_axis_label="Counts", ) self.Add(self.wxgui_scopesink2_0.win) self.gr_udp_source_1 = gr.udp_source(gr.sizeof_short*1, "127.0.0.1", 1235, 2, True, True) self.gr_short_to_float_0_0 = gr.short_to_float() ################################################## # Connections ################################################## self.connect((self.gr_udp_source_1, 0), (self.gr_short_to_float_0_0, 0)) self.connect((self.gr_short_to_float_0_0, 0), (self.wxgui_scopesink2_0, 0))
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 self.remove_head = remove_head = 0 ################################################## # Blocks ################################################## self._remove_head_chooser = forms.radio_buttons( parent=self.GetWin(), value=self.remove_head, callback=self.set_remove_head, label="Remove Head", choices=[0,1], labels=[], style=wx.RA_HORIZONTAL, ) self.Add(self._remove_head_chooser) self.wxgui_scopesink2_0 = scopesink2.scope_sink_f( self.GetWin(), title="Scope Plot", sample_rate=samp_rate, v_scale=0, v_offset=0, t_scale=0, ac_couple=False, xy_mode=False, num_inputs=2, trig_mode=gr.gr_TRIG_MODE_AUTO, y_axis_label="Counts", ) self.Add(self.wxgui_scopesink2_0.win) self.gr_udp_source_0 = gr.udp_source(gr.sizeof_short*1, "192.168.2.200", 9997, 590, False, True) self.gr_short_to_float_0_0 = gr.short_to_float(1, 1) self.gr_short_to_float_0 = gr.short_to_float(1, 1) self.gr_file_sink_0_1_0 = gr.file_sink(gr.sizeof_short*1, "/home/cgardner/sandbox/gr-csg/gr-fp/grc_testfp/test_fp_odd.bin") self.gr_file_sink_0_1_0.set_unbuffered(True) self.gr_file_sink_0_1 = gr.file_sink(gr.sizeof_short*1, "/home/cgardner/sandbox/gr-csg/gr-fp/grc_testfp/test_raw_even.bin") self.gr_file_sink_0_1.set_unbuffered(True) self.gr_deinterleave_0 = gr.deinterleave(gr.sizeof_short*1) self.fpgnu_fpdata_sink_0 = fpgnu_swig.fpdata_sink(remove_head) ################################################## # Connections ################################################## self.connect((self.gr_udp_source_0, 0), (self.fpgnu_fpdata_sink_0, 0)) self.connect((self.gr_short_to_float_0, 0), (self.wxgui_scopesink2_0, 0)) self.connect((self.gr_deinterleave_0, 1), (self.gr_file_sink_0_1_0, 0)) self.connect((self.fpgnu_fpdata_sink_0, 0), (self.gr_deinterleave_0, 0)) self.connect((self.gr_deinterleave_0, 0), (self.gr_file_sink_0_1, 0)) self.connect((self.gr_short_to_float_0_0, 0), (self.wxgui_scopesink2_0, 1)) self.connect((self.gr_deinterleave_0, 1), (self.gr_short_to_float_0_0, 0)) self.connect((self.gr_deinterleave_0, 0), (self.gr_short_to_float_0, 0))
def __init__(self, host, port, pkt_size, sample_rate, eof, wait): gr.top_block.__init__(self, "dial_tone_sink") udp = gr.udp_source(gr.sizeof_float, host, port, pkt_size, eof=eof, wait=wait) sink = audio.sink(sample_rate) self.connect(udp, sink)
def __init__(self, host, port, pkt_size, sample_rate, eof, wait): gr.top_block.__init__(self, "audio_sink") src = gr.udp_source(gr.sizeof_float, host, port, pkt_size, eof=eof, wait=wait) dst = audio.sink(sample_rate) self.connect(src, dst)
def xUdpSource(self, address): # ------------------------------------------------------------------------ try: host, port = address.split(":") except: print "UdpSourceAdapter.xUdpSource: Bad address \"%s\"" % address return None try: return gr.udp_source( gr.sizeof_float, host, int(port), 1472, False, True) except: print "UdpSourceAdapter.xUdpSource: Blown creation \"%s\"" % address return None
def __init__(self): gr.top_block.__init__(self, "Burst View") Qt.QWidget.__init__(self) self.setWindowTitle("Burst View") self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) 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) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 1e6 ################################################## # Blocks ################################################## self.qtgui_sink_x_0 = qtgui.sink_c( 1024, #fftsize firdes.WIN_BLACKMAN_hARRIS, #wintype 0, #fc samp_rate, #bw "QT GUI Plot", #name True, #plotfreq True, #plotwaterfall True, #plottime True, #plotconst ) self.qtgui_sink_x_0.set_update_time(1.0/10) self._qtgui_sink_x_0_win = sip.wrapinstance(self.qtgui_sink_x_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_sink_x_0_win) self.gr_udp_source_0 = gr.udp_source(gr.sizeof_gr_complex*1, "127.0.0.1", 12345, 1472, True, True) ################################################## # Connections ################################################## self.connect((self.gr_udp_source_0, 0), (self.qtgui_sink_x_0, 0))
def __init__(self, twisted_con, tcp_addr, tcp_port, app_center_freq, app_samp_rate, sim_bw, sim_center_freq): gr.hier_block2.__init__(self, "tw2gr_c", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, gr.sizeof_gr_complex)) self.tw2gr = tw2gr_cc(twisted_con) # self.tcp_source = tcp_source(itemsize=gr.sizeof_gr_complex, # addr=tcp_addr, # port=tcp_port, # server=True) self.tcp_source = gr.udp_source(itemsize=gr.sizeof_gr_complex, host=str(tcp_addr), port=tcp_port, payload_size=1472, eof=False, wait=True) print "Connecting tw2gr..." self.connect(self.tcp_source, self.tw2gr, self)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.gr_udp_source_0 = gr.udp_source(gr.sizeof_float*1, "192.168.2.200", 9997, 18*50, False, True) self.gr_file_sink_0_1 = gr.file_sink(gr.sizeof_float*1, "testme.bin") self.gr_file_sink_0_1.set_unbuffered(True) self.fpgnu_fpdata_sink_0 = fpgnu_swig.fpdata_sink() ################################################## # Connections ################################################## self.connect((self.fpgnu_fpdata_sink_0, 0), (self.gr_file_sink_0_1, 0)) self.connect((self.gr_udp_source_0, 0), (self.fpgnu_fpdata_sink_0, 0))
def __init__(self, src, port, pkt_size): gr.top_block.__init__(self, "vector_sink") udp = gr.udp_source(gr.sizeof_float, src, port, pkt_size) sink = gr.file_sink(gr.sizeof_float, "received.dat") self.connect(udp, sink)
def _set_source(self): options = self.options self.usrp = gr.udp_source(gr.sizeof_gr_complex, "localhost", 63223) return self.usrp
def __init__(self, frame, panel, vbox, argv): MAX_CHANNELS = 7 stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) parser = OptionParser(option_class=eng_option) parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None, help="select USRP Tx side A or B") parser.add_option("-e", "--enable-fft", action="store_true", default=False, help="enable spectrum plot (and use more CPU)") parser.add_option("-f", "--freq", type="eng_float", default=None, help="set Tx frequency to FREQ [required]", metavar="FREQ") parser.add_option("-i", "--file-input", action="store_true", default=False, help="input from baseband-0.dat, baseband-1.dat ...") parser.add_option("-g", "--audio-gain", type="eng_float", default=1.0, help="input audio gain multiplier") parser.add_option("-n", "--nchannels", type="int", default=2, help="number of Tx channels [1,4]") parser.add_option("-a", "--udp-addr", type="string", default="127.0.0.1", help="UDP host IP address") parser.add_option("-p", "--udp-port", type="int", default=0, help="UDP port number") parser.add_option("-r", "--repeat", action="store_true", default=False, help="continuously replay input file") parser.add_option("-S", "--stretch", type="int", default=0, help="elastic buffer trigger value") parser.add_option("-v", "--verbose", action="store_true", default=False, help="print out stats") parser.add_option( "-I", "--audio-input", type="string", default="", help="pcm input device name. E.g., hw:0,0 or /dev/dsp") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) if options.nchannels < 1 or options.nchannels > MAX_CHANNELS: sys.stderr.write( "op25_tx: nchannels out of range. Must be in [1,%d]\n" % MAX_CHANNELS) sys.exit(1) if options.freq is None: sys.stderr.write("op25_tx: must specify frequency with -f FREQ\n") parser.print_help() sys.exit(1) # ---------------------------------------------------------------- # Set up constants and parameters self.u = usrp.sink_c() # the USRP sink (consumes samples) self.dac_rate = self.u.dac_rate() # 128 MS/s self.usrp_interp = 400 self.u.set_interp_rate(self.usrp_interp) self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s self.sw_interp = 10 self.audio_rate = self.usrp_rate / self.sw_interp # 32 kS/s # determine the daughterboard subdevice we're using if options.tx_subdev_spec is None: options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u) m = usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec) #print "mux = %#04x" % (m,) self.u.set_mux(m) self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec) print "Using TX d'board %s" % (self.subdev.side_and_name(), ) self.subdev.set_gain(self.subdev.gain_range()[0]) # set min Tx gain if not self.set_freq(options.freq): freq_range = self.subdev.freq_range() print "Failed to set frequency to %s. Daughterboard supports %s to %s" % ( eng_notation.num_to_str( options.freq), eng_notation.num_to_str( freq_range[0]), eng_notation.num_to_str(freq_range[1])) raise SystemExit self.subdev.set_enable(True) # enable transmitter # instantiate vocoders self.vocoders = [] if options.file_input: for i in range(options.nchannels): t = gr.file_source(gr.sizeof_char, "baseband-%d.dat" % i, options.repeat) self.vocoders.append(t) elif options.udp_port > 0: self.udp_sources = [] for i in range(options.nchannels): t = gr.udp_source(1, options.udp_addr, options.udp_port + i, 216) self.udp_sources.append(t) arity = 2 t = gr.packed_to_unpacked_bb(arity, gr.GR_MSB_FIRST) self.vocoders.append(t) self.connect(self.udp_sources[i], self.vocoders[i]) else: self.audio_amps = [] self.converters = [] input_audio_rate = 8000 self.audio_input = audio.source(input_audio_rate, options.audio_input) for i in range(options.nchannels): t = gr.multiply_const_ff(32767 * options.audio_gain) self.audio_amps.append(t) t = gr.float_to_short() self.converters.append(t) t = repeater.vocoder( True, # 0=Decode,True=Encode options.verbose, # Verbose flag options.stretch, # flex amount "", # udp ip address 0, # udp port False) # dump raw u vectors self.vocoders.append(t) self.connect((self.audio_input, i), self.audio_amps[i], self.converters[i], self.vocoders[i]) sum = gr.add_cc() # Instantiate N NBFM channels step = 25e3 offset = (0 * step, 1 * step, -1 * step, 2 * step, -2 * step, 3 * step, -3 * step) for i in range(options.nchannels): t = pipeline(self.vocoders[i], offset[i], self.audio_rate, self.usrp_rate) self.connect(t, (sum, i)) gain = gr.multiply_const_cc(4000.0 / options.nchannels) # connect it all self.connect(sum, gain) self.connect(gain, self.u) # plot an FFT to verify we are sending what we want if options.enable_fft: post_mod = fftsink2.fft_sink_c(panel, title="Post Modulation", fft_size=512, sample_rate=self.usrp_rate, y_per_div=20, ref_level=40) self.connect(sum, post_mod) vbox.Add(post_mod.win, 1, wx.EXPAND)
def __init__(self, options, args, queue): gr.top_block.__init__(self) self.options = options self.args = args self.rate = int(options.rate) if options.filename is None and options.udp is None and not options.rtlsdr: #UHD source by default from gnuradio import uhd self.u = uhd.single_usrp_source(options.args, uhd.io_type_t.COMPLEX_FLOAT32, 1) time_spec = uhd.time_spec(0.0) self.u.set_time_now(time_spec) #if(options.rx_subdev_spec is None): # options.rx_subdev_spec = "" #self.u.set_subdev_spec(options.rx_subdev_spec) if not options.antenna is None: self.u.set_antenna(options.antenna) self.u.set_samp_rate(rate) self.rate = int(self.u.get_samp_rate()) #retrieve actual if options.gain is None: #set to halfway g = self.u.get_gain_range() options.gain = (g.start()+g.stop()) / 2.0 if not(self.tune(options.freq)): print "Failed to set initial frequency" print "Setting gain to %i" % options.gain self.u.set_gain(options.gain) print "Gain is %i" % self.u.get_gain() elif options.rtlsdr: #RTLSDR dongle import osmosdr self.u = osmosdr.source_c(options.args) self.u.set_sample_rate(2.4e6) #fixed for RTL dongles if not self.u.set_center_freq(options.centerfreq - options.error): print "Failed to set initial frequency" self.u.set_gain_mode(0) #manual gain mode if options.gain is None: options.gain = 25#34 self.u.set_gain(options.gain) print "Gain is %i" % self.u.get_gain() use_resampler = True self.rate=2.4e6 else: if options.filename is not None: self.u = gr.file_source(gr.sizeof_gr_complex, options.filename) elif options.udp is not None: self.u = gr.udp_source(gr.sizeof_gr_complex, "localhost", options.udp) else: raise Exception("No valid source selected") print "Samples per second is %i" % self.rate self._syms_per_sec = 3600; options.audiorate = 11025 options.rate = self.rate options.samples_per_second = self.rate #yeah i know it's on the list options.syms_per_sec = self._syms_per_sec options.gain_mu = 0.01 options.mu=0.5 options.omega_relative_limit = 0.3 options.syms_per_sec = self._syms_per_sec options.offset = options.centerfreq - options.freq print "Control channel offset: %f" % options.offset self.demod = fsk_demod(options) self.start_correlator = gr.correlate_access_code_tag_bb("10101100",0,"smartnet_preamble") #should mark start of packet #digital. #self.start_correlator = digital.correlate_access_code_bb("10101100",0) #should mark start of packet #digital. # self.smartnet_sync = smartnet.sync() self.smartnet_deinterleave = smartnet.deinterleave() # self.smartnet_parity = smartnet.parity() self.smartnet_crc = smartnet.crc(queue) # self.smartnet_packetize = smartnet.packetize() # self.parse = smartnet.parse(queue) #packet-based. this simply posts lightly-formatted messages to the queue. self.connect(self.u, self.demod) #self.smartnet_sync, self.smartnet_parity, self.connect(self.demod, self.start_correlator, self.smartnet_deinterleave, self.smartnet_crc)#, self.smartnet_packetize, self.parse)
def __init__(self, frame, panel, vbox, argv): MAX_CHANNELS = 7 stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv) parser = OptionParser (option_class=eng_option) parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None, help="select USRP Tx side A or B") parser.add_option("-e","--enable-fft", action="store_true", default=False, help="enable spectrum plot (and use more CPU)") parser.add_option("-f", "--freq", type="eng_float", default=None, help="set Tx frequency to FREQ [required]", metavar="FREQ") parser.add_option("-i","--file-input", action="store_true", default=False, help="input from baseband-0.dat, baseband-1.dat ...") parser.add_option("-g", "--audio-gain", type="eng_float", default=1.0, help="input audio gain multiplier") parser.add_option("-n", "--nchannels", type="int", default=1, help="number of Tx channels [1,4]") parser.add_option("-a", "--udp-addr", type="string", default="127.0.0.1", help="UDP host IP address") parser.add_option("--args", type="string", default="", help="device args") parser.add_option("--gains", type="string", default="", help="gains") parser.add_option("-p", "--udp-port", type="int", default=0, help="UDP port number") parser.add_option("-r","--repeat", action="store_true", default=False, help="continuously replay input file") parser.add_option("-S", "--stretch", type="int", default=0, help="elastic buffer trigger value") parser.add_option("-v","--verbose", action="store_true", default=False, help="print out stats") parser.add_option("-I", "--audio-input", type="string", default="", help="pcm input device name. E.g., hw:0,0 or /dev/dsp") (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() sys.exit(1) if options.nchannels < 1 or options.nchannels > MAX_CHANNELS: sys.stderr.write ("op25_tx: nchannels out of range. Must be in [1,%d]\n" % MAX_CHANNELS) sys.exit(1) if options.freq is None: sys.stderr.write("op25_tx: must specify frequency with -f FREQ\n") parser.print_help() sys.exit(1) # ---------------------------------------------------------------- # Set up constants and parameters self.u = osmosdr.sink (options.args) # the USRP sink (consumes samples) gain_names = self.u.get_gain_names() for name in gain_names: gain_range = self.u.get_gain_range(name) print "gain: name: %s range: start %d stop %d step %d" % (name, gain_range[0].start(), gain_range[0].stop(), gain_range[0].step()) if options.gains: for tuple in options.gains.split(","): name, gain = tuple.split(":") gain = int(gain) print "setting gain %s to %d" % (name, gain) self.u.set_gain(gain, name) self.usrp_rate = 320000 print 'setting sample rate' self.u.set_sample_rate(self.usrp_rate) self.u.set_center_freq(int(options.freq)) #self.u.set_bandwidth(self.usrp_rate) #self.u = blocks.file_sink(gr.sizeof_gr_complex, 'usrp-samp.dat') #self.dac_rate = self.u.dac_rate() # 128 MS/s #self.usrp_interp = 400 #self.u.set_interp_rate(self.usrp_interp) #self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s #self.sw_interp = 10 #self.audio_rate = self.usrp_rate / self.sw_interp # 32 kS/s self.audio_rate = 32000 # if not self.set_freq(options.freq): # freq_range = self.subdev.freq_range() # print "Failed to set frequency to %s. Daughterboard supports %s to %s" % ( # eng_notation.num_to_str(options.freq), # eng_notation.num_to_str(freq_range[0]), # eng_notation.num_to_str(freq_range[1])) # raise SystemExit # self.subdev.set_enable(True) # enable transmitter # instantiate vocoders self.vocoders = [] if options.file_input: i = 0 t = blocks.file_source(gr.sizeof_char, "baseband-%d.dat" % i, options.repeat) self.vocoders.append(t) elif options.udp_port > 0: self.udp_sources = [] for i in range (options.nchannels): t = gr.udp_source(1, options.udp_addr, options.udp_port + i, 216) self.udp_sources.append(t) arity = 2 t = gr.packed_to_unpacked_bb(arity, gr.GR_MSB_FIRST) self.vocoders.append(t) self.connect(self.udp_sources[i], self.vocoders[i]) if 1: # else: input_audio_rate = 8000 #self.audio_input = audio.source(input_audio_rate, options.audio_input) af = 1333 audio_input = analog.sig_source_s( input_audio_rate, analog.GR_SIN_WAVE, af, 15000) t = op25_repeater.vocoder(True, # 0=Decode,True=Encode options.verbose, # Verbose flag options.stretch, # flex amount "", # udp ip address 0, # udp port False) # dump raw u vectors self.connect(audio_input, t) self.vocoders.append(t) sum = blocks.add_cc () # Instantiate N NBFM channels step = 100e3 offset = (0 * step, -1 * step, +1 * step, 2 * step, -2 * step, 3 * step, -3 * step) for i in range (options.nchannels): t = pipeline(self.vocoders[i], offset[i], self.audio_rate, self.usrp_rate) self.connect(t, (sum, i)) t = file_pipeline(offset[2], self.usrp_rate, '2013-320k-filt.dat') self.connect(t, (sum, options.nchannels)) gain = blocks.multiply_const_cc (0.75 / (options.nchannels+1)) # connect it all self.connect (sum, gain) self.connect (gain, self.u) # plot an FFT to verify we are sending what we want if options.enable_fft: post_mod = fftsink2.fft_sink_c(panel, title="Post Modulation", fft_size=512, sample_rate=self.usrp_rate, y_per_div=20, ref_level=40) self.connect (sum, post_mod) vbox.Add (post_mod.win, 1, wx.EXPAND)
self._created = True #print "Created remote device: %s" % (self._name) #self._send("HEADER", "OFF") # Enhanced udp_source if sample_rate is not None: self._send_and_wait_for_ok("RATE", sample_rate) else: #sample_rate = self.adc_freq() / decim_rate if self.set_decim_rate(decim_rate) == False: raise Exception, "Invalid decimation: %s (sample rate: %s)" % (decim_rate, sample_rate) if self.udp_source is None: assert self.vec2stream is None and self.ishort2complex is None udp_interface = "0.0.0.0" # MAGIC self.udp_source = gr.udp_source(gr.sizeof_short * 2, udp_interface, udp_port, self._packet_size, True, True, True) #print "--> UDP Source listening on port:", udp_port, "interface:", udp_interface, "MTU:", self._packet_size self.vec2stream = gr.vector_to_stream(gr.sizeof_short * 1, 2) self.ishort2complex = gr.interleaved_short_to_complex() self.connect(self.udp_source, self.vec2stream, self.ishort2complex, self) else: assert self.vec2stream is not None and self.ishort2complex is not None if self._listen_only == False: if self._last_antenna is not None: self.select_rx_antenna(self._last_antenna) if self._last_freq is not None: self.set_freq(self._last_freq) if self._last_gain is not None: self.set_gain(self._last_gain)
def __init__(self, frame, panel, vbox, argv): MAX_CHANNELS = 7 stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv) parser = OptionParser (option_class=eng_option) parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None, help="select USRP Tx side A or B") parser.add_option("-e","--enable-fft", action="store_true", default=False, help="enable spectrum plot (and use more CPU)") parser.add_option("-f", "--freq", type="eng_float", default=None, help="set Tx frequency to FREQ [required]", metavar="FREQ") parser.add_option("-i","--file-input", action="store_true", default=False, help="input from baseband-0.dat, baseband-1.dat ...") parser.add_option("-g", "--audio-gain", type="eng_float", default=1.0, help="input audio gain multiplier") parser.add_option("-n", "--nchannels", type="int", default=2, help="number of Tx channels [1,4]") parser.add_option("-a", "--udp-addr", type="string", default="127.0.0.1", help="UDP host IP address") parser.add_option("-p", "--udp-port", type="int", default=0, help="UDP port number") parser.add_option("-r","--repeat", action="store_true", default=False, help="continuously replay input file") parser.add_option("-S", "--stretch", type="int", default=0, help="elastic buffer trigger value") parser.add_option("-v","--verbose", action="store_true", default=False, help="print out stats") parser.add_option("-I", "--audio-input", type="string", default="", help="pcm input device name. E.g., hw:0,0 or /dev/dsp") (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() sys.exit(1) if options.nchannels < 1 or options.nchannels > MAX_CHANNELS: sys.stderr.write ("op25_tx: nchannels out of range. Must be in [1,%d]\n" % MAX_CHANNELS) sys.exit(1) if options.freq is None: sys.stderr.write("op25_tx: must specify frequency with -f FREQ\n") parser.print_help() sys.exit(1) # ---------------------------------------------------------------- # Set up constants and parameters self.u = usrp.sink_c () # the USRP sink (consumes samples) self.dac_rate = self.u.dac_rate() # 128 MS/s self.usrp_interp = 400 self.u.set_interp_rate(self.usrp_interp) self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s self.sw_interp = 10 self.audio_rate = self.usrp_rate / self.sw_interp # 32 kS/s # determine the daughterboard subdevice we're using if options.tx_subdev_spec is None: options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u) m = usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec) #print "mux = %#04x" % (m,) self.u.set_mux(m) self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec) print "Using TX d'board %s" % (self.subdev.side_and_name(),) self.subdev.set_gain(self.subdev.gain_range()[0]) # set min Tx gain if not self.set_freq(options.freq): freq_range = self.subdev.freq_range() print "Failed to set frequency to %s. Daughterboard supports %s to %s" % ( eng_notation.num_to_str(options.freq), eng_notation.num_to_str(freq_range[0]), eng_notation.num_to_str(freq_range[1])) raise SystemExit self.subdev.set_enable(True) # enable transmitter # instantiate vocoders self.vocoders = [] if options.file_input: for i in range (options.nchannels): t = gr.file_source(gr.sizeof_char, "baseband-%d.dat" % i, options.repeat) self.vocoders.append(t) elif options.udp_port > 0: self.udp_sources = [] for i in range (options.nchannels): t = gr.udp_source(1, options.udp_addr, options.udp_port + i, 216) self.udp_sources.append(t) arity = 2 t = gr.packed_to_unpacked_bb(arity, gr.GR_MSB_FIRST) self.vocoders.append(t) self.connect(self.udp_sources[i], self.vocoders[i]) else: self.audio_amps = [] self.converters = [] input_audio_rate = 8000 self.audio_input = audio.source(input_audio_rate, options.audio_input) for i in range (options.nchannels): t = gr.multiply_const_ff(32767 * options.audio_gain) self.audio_amps.append(t) t = gr.float_to_short() self.converters.append(t) t = repeater.vocoder(True, # 0=Decode,True=Encode options.verbose, # Verbose flag options.stretch, # flex amount "", # udp ip address 0, # udp port False) # dump raw u vectors self.vocoders.append(t) self.connect((self.audio_input, i), self.audio_amps[i], self.converters[i], self.vocoders[i]) sum = gr.add_cc () # Instantiate N NBFM channels step = 25e3 offset = (0 * step, 1 * step, -1 * step, 2 * step, -2 * step, 3 * step, -3 * step) for i in range (options.nchannels): t = pipeline(self.vocoders[i], offset[i], self.audio_rate, self.usrp_rate) self.connect(t, (sum, i)) gain = gr.multiply_const_cc (4000.0 / options.nchannels) # connect it all self.connect (sum, gain) self.connect (gain, self.u) # plot an FFT to verify we are sending what we want if options.enable_fft: post_mod = fftsink2.fft_sink_c(panel, title="Post Modulation", fft_size=512, sample_rate=self.usrp_rate, y_per_div=20, ref_level=40) self.connect (sum, post_mod) vbox.Add (post_mod.win, 1, wx.EXPAND)
def __init__(self, options, args, queue): gr.top_block.__init__(self) self.options = options self.args = args rate = int(options.rate) use_resampler = False if options.filename is None and options.udp is None and not options.rtlsdr: #UHD source by default from gnuradio import uhd self.u = uhd.single_usrp_source("", uhd.io_type_t.COMPLEX_FLOAT32, 1) time_spec = uhd.time_spec(0.0) self.u.set_time_now(time_spec) #if(options.rx_subdev_spec is None): # options.rx_subdev_spec = "" #self.u.set_subdev_spec(options.rx_subdev_spec) if not options.antenna is None: self.u.set_antenna(options.antenna) self.u.set_samp_rate(rate) rate = int(self.u.get_samp_rate()) #retrieve actual if options.gain is None: #set to halfway g = self.u.get_gain_range() options.gain = (g.start()+g.stop()) / 2.0 if not(self.tune(options.freq)): print "Failed to set initial frequency" print "Setting gain to %i" % options.gain self.u.set_gain(options.gain) print "Gain is %i" % self.u.get_gain() elif options.rtlsdr: #RTLSDR dongle import osmosdr self.u = osmosdr.source_c() self.u.set_sample_rate(2.4e6) #fixed for RTL dongles if not self.u.set_center_freq(options.freq): print "Failed to set initial frequency" self.u.set_gain_mode(0) #manual gain mode if options.gain is None: options.gain = 49 self.u.set_gain(options.gain) print "Gain is %i" % self.u.get_gain() use_resampler = True else: if options.filename is not None: self.u = gr.file_source(gr.sizeof_gr_complex, options.filename) elif options.udp is not None: self.u = gr.udp_source(gr.sizeof_gr_complex, "localhost", options.udp) else: raise Exception("No valid source selected") print "Rate is %i" % (rate,) pass_all = 0 if options.output_all : pass_all = 1 self.demod = gr.complex_to_mag() self.avg = gr.moving_average_ff(100, 1.0/100, 400) self.preamble = air_modes.modes_preamble(rate, options.threshold) #self.framer = air_modes.modes_framer(rate) self.slicer = air_modes.modes_slicer(rate, queue) if use_resampler: self.lpfiltcoeffs = gr.firdes.low_pass(1, 5*2.4e6, 1.2e6, 300e3) self.resample = blks2.rational_resampler_ccf(interpolation=5, decimation=3, taps=self.lpfiltcoeffs) self.connect(self.u, self.resample, self.demod) else: self.connect(self.u, self.demod) self.connect(self.demod, self.avg) self.connect(self.demod, (self.preamble, 0)) self.connect(self.avg, (self.preamble, 1)) self.connect((self.preamble, 0), (self.slicer, 0))
def _setup_source(self, options): if options.source == "uhd": #UHD source by default from gnuradio import uhd self._u = uhd.single_usrp_source(options.args, uhd.io_type_t.COMPLEX_FLOAT32, 1) if (options.subdev): self._u.set_subdev_spec(options.subdev, 0) if not self._u.set_center_freq(options.freq): print "Failed to set initial frequency" #check for GPSDO #if you have a GPSDO, UHD will automatically set the timestamp to UTC time #as well as automatically set the clock to lock to GPSDO. if self._u.get_time_source(0) != 'gpsdo': self._u.set_time_now(uhd.time_spec(0.0)) if options.antenna is not None: self._u.set_antenna(options.antenna) self._u.set_samp_rate(options.rate) options.rate = int(self._u.get_samp_rate()) #retrieve actual if options.gain is None: #set to halfway g = self._u.get_gain_range() options.gain = (g.start() + g.stop()) / 2.0 print "Setting gain to %i" % options.gain self._u.set_gain(options.gain) print "Gain is %i" % self._u.get_gain() #TODO: detect if you're using an RTLSDR or Jawbreaker #and set up accordingly. elif options.source == "osmocom": #RTLSDR dongle or HackRF Jawbreaker import osmosdr self._u = osmosdr.source(options.args) # self._u.set_sample_rate(3.2e6) #fixed for RTL dongles self._u.set_sample_rate(options.rate) if not self._u.set_center_freq(options.freq): print "Failed to set initial frequency" # self._u.set_gain_mode(0) #manual gain mode if options.gain is None: options.gain = 34 self._u.set_gain(options.gain) print "Gain is %i" % self._u.get_gain() #Note: this should only come into play if using an RTLSDR. # lpfiltcoeffs = gr.firdes.low_pass(1, 5*3.2e6, 1.6e6, 300e3) # self._resample = filter.rational_resampler_ccf(interpolation=5, decimation=4, taps=lpfiltcoeffs) else: #semantically detect whether it's ip.ip.ip.ip:port or filename if ':' in options.source: try: ip, port = re.search("(.*)\:(\d{1,5})", options.source).groups() except: raise Exception( "Please input UDP source e.g. 192.168.10.1:12345") self._u = gr.udp_source(gr.sizeof_gr_complex, ip, int(port)) print "Using UDP source %s:%s" % (ip, port) else: self._u = blocks.file_source(gr.sizeof_gr_complex, options.source) print "Using file source %s" % options.source print "Rate is %i" % (options.rate, )
def __init__(self, frame, panel, vbox, argv): MAX_CHANNELS = 7 stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv) parser = OptionParser (option_class=eng_option) parser.add_option("-T", "--tx-subdev-spec", type="subdev", default=None, help="select USRP Tx side A or B") parser.add_option("-e","--enable-fft", action="store_true", default=False, help="enable spectrum plot (and use more CPU)") parser.add_option("-f", "--freq", type="eng_float", default=None, help="set Tx frequency to FREQ [required]", metavar="FREQ") parser.add_option("-i","--file-input", action="store_true", default=False, help="input from baseband-0.dat, baseband-1.dat ...") parser.add_option("-g", "--audio-gain", type="eng_float", default=1.0, help="input audio gain multiplier") parser.add_option("-n", "--nchannels", type="int", default=1, help="number of Tx channels [1,4]") parser.add_option("-a", "--udp-addr", type="string", default="127.0.0.1", help="UDP host IP address") parser.add_option("--args", type="string", default="", help="device args") parser.add_option("--gains", type="string", default="", help="gains") parser.add_option("-p", "--udp-port", type="int", default=0, help="UDP port number") parser.add_option("-r","--repeat", action="store_true", default=False, help="continuously replay input file") parser.add_option("-S", "--stretch", type="int", default=0, help="elastic buffer trigger value") parser.add_option("-v","--verbose", action="store_true", default=False, help="print out stats") parser.add_option("-I", "--audio-input", type="string", default="", help="pcm input device name. E.g., hw:0,0 or /dev/dsp") (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() sys.exit(1) if options.nchannels < 1 or options.nchannels > MAX_CHANNELS: sys.stderr.write ("op25_tx: nchannels out of range. Must be in [1,%d]\n" % MAX_CHANNELS) sys.exit(1) if options.freq is None: sys.stderr.write("op25_tx: must specify frequency with -f FREQ\n") parser.print_help() sys.exit(1) # ---------------------------------------------------------------- # Set up constants and parameters self.u = osmosdr.sink (options.args) # the USRP sink (consumes samples) gain_names = self.u.get_gain_names() for name in gain_names: gain_range = self.u.get_gain_range(name) print("gain: name: %s range: start %d stop %d step %d" % (name, gain_range[0].start(), gain_range[0].stop(), gain_range[0].step())) if options.gains: for tuple in options.gains.split(","): name, gain = tuple.split(":") gain = int(gain) print("setting gain %s to %d" % (name, gain)) self.u.set_gain(gain, name) self.usrp_rate = 320000 print('setting sample rate') self.u.set_sample_rate(self.usrp_rate) self.u.set_center_freq(int(options.freq)) #self.u.set_bandwidth(self.usrp_rate) #self.u = blocks.file_sink(gr.sizeof_gr_complex, 'usrp-samp.dat') #self.dac_rate = self.u.dac_rate() # 128 MS/s #self.usrp_interp = 400 #self.u.set_interp_rate(self.usrp_interp) #self.usrp_rate = self.dac_rate / self.usrp_interp # 320 kS/s #self.sw_interp = 10 #self.audio_rate = self.usrp_rate / self.sw_interp # 32 kS/s self.audio_rate = 32000 # if not self.set_freq(options.freq): # freq_range = self.subdev.freq_range() # print "Failed to set frequency to %s. Daughterboard supports %s to %s" % ( # eng_notation.num_to_str(options.freq), # eng_notation.num_to_str(freq_range[0]), # eng_notation.num_to_str(freq_range[1])) # raise SystemExit # self.subdev.set_enable(True) # enable transmitter # instantiate vocoders self.vocoders = [] if options.file_input: i = 0 t = blocks.file_source(gr.sizeof_char, "baseband-%d.dat" % i, options.repeat) self.vocoders.append(t) elif options.udp_port > 0: self.udp_sources = [] for i in range (options.nchannels): t = gr.udp_source(1, options.udp_addr, options.udp_port + i, 216) self.udp_sources.append(t) arity = 2 t = gr.packed_to_unpacked_bb(arity, gr.GR_MSB_FIRST) self.vocoders.append(t) self.connect(self.udp_sources[i], self.vocoders[i]) if 1: # else: input_audio_rate = 8000 #self.audio_input = audio.source(input_audio_rate, options.audio_input) af = 1333 audio_input = analog.sig_source_s( input_audio_rate, analog.GR_SIN_WAVE, af, 15000) t = op25_repeater.vocoder(True, # 0=Decode,True=Encode options.verbose, # Verbose flag options.stretch, # flex amount "", # udp ip address 0, # udp port False) # dump raw u vectors self.connect(audio_input, t) self.vocoders.append(t) sum = blocks.add_cc () # Instantiate N NBFM channels step = 100e3 offset = (0 * step, -1 * step, +1 * step, 2 * step, -2 * step, 3 * step, -3 * step) for i in range (options.nchannels): t = pipeline(self.vocoders[i], offset[i], self.audio_rate, self.usrp_rate) self.connect(t, (sum, i)) t = file_pipeline(offset[2], self.usrp_rate, '2013-320k-filt.dat') self.connect(t, (sum, options.nchannels)) gain = blocks.multiply_const_cc (0.75 / (options.nchannels+1)) # connect it all self.connect (sum, gain) self.connect (gain, self.u) # plot an FFT to verify we are sending what we want if options.enable_fft: post_mod = fftsink2.fft_sink_c(panel, title="Post Modulation", fft_size=512, sample_rate=self.usrp_rate, y_per_div=20, ref_level=40) self.connect (sum, post_mod) vbox.Add (post_mod.win, 1, wx.EXPAND)
def _setup_source(self, options): if options.source == "uhd": #UHD source by default from gnuradio import uhd self._u = uhd.single_usrp_source(options.args, uhd.io_type_t.COMPLEX_FLOAT32, 1) if(options.subdev): self._u.set_subdev_spec(options.subdev, 0) if not self._u.set_center_freq(options.freq): print "Failed to set initial frequency" #check for GPSDO #if you have a GPSDO, UHD will automatically set the timestamp to UTC time #as well as automatically set the clock to lock to GPSDO. if self._u.get_time_source(0) != 'gpsdo': self._u.set_time_now(uhd.time_spec(0.0)) if options.antenna is not None: self._u.set_antenna(options.antenna) self._u.set_samp_rate(options.rate) options.rate = int(self._u.get_samp_rate()) #retrieve actual if options.gain is None: #set to halfway g = self._u.get_gain_range() options.gain = (g.start()+g.stop()) / 2.0 print "Setting gain to %i" % options.gain self._u.set_gain(options.gain) print "Gain is %i" % self._u.get_gain() #TODO: detect if you're using an RTLSDR or Jawbreaker #and set up accordingly. elif options.source == "osmocom": #RTLSDR dongle or HackRF Jawbreaker import osmosdr self._u = osmosdr.source(options.args) # self._u.set_sample_rate(3.2e6) #fixed for RTL dongles self._u.set_sample_rate(options.rate) if not self._u.set_center_freq(options.freq): print "Failed to set initial frequency" # self._u.set_gain_mode(0) #manual gain mode if options.gain is None: options.gain = 34 self._u.set_gain(options.gain) print "Gain is %i" % self._u.get_gain() #Note: this should only come into play if using an RTLSDR. # lpfiltcoeffs = gr.firdes.low_pass(1, 5*3.2e6, 1.6e6, 300e3) # self._resample = filter.rational_resampler_ccf(interpolation=5, decimation=4, taps=lpfiltcoeffs) else: #semantically detect whether it's ip.ip.ip.ip:port or filename if ':' in options.source: try: ip, port = re.search("(.*)\:(\d{1,5})", options.source).groups() except: raise Exception("Please input UDP source e.g. 192.168.10.1:12345") self._u = gr.udp_source(gr.sizeof_gr_complex, ip, int(port)) print "Using UDP source %s:%s" % (ip, port) else: self._u = blocks.file_source(gr.sizeof_gr_complex, options.source) print "Using file source %s" % options.source print "Rate is %i" % (options.rate,)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="RTL-SDR to Pure Data") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 1920000 self.cur_freq_fine = cur_freq_fine = 0 self.cur_freq = cur_freq = 0 self.channels_coeffs_0 = channels_coeffs_0 = gr.firdes.low_pass(1.0,samp_rate,20000,25000,gr.firdes.WIN_HAMMING) self.channels_coeffs = channels_coeffs = gr.firdes.low_pass(1.0,samp_rate,20000,45000,gr.firdes.WIN_HAMMING) ################################################## # Blocks ################################################## self.signal_cur = gr.probe_signal_f() self.fine_cur = gr.probe_signal_f() self.rtlsdr_source_c_0 = osmosdr.source_c( args="nchan=" + str(1) + " " + "" ) self.rtlsdr_source_c_0.set_sample_rate(samp_rate) self.rtlsdr_source_c_0.set_center_freq(78000000, 0) self.rtlsdr_source_c_0.set_freq_corr(0, 0) self.rtlsdr_source_c_0.set_gain_mode(0, 0) self.rtlsdr_source_c_0.set_gain(10, 0) self.rtlsdr_source_c_0.set_if_gain(24, 0) self.gr_udp_source_0_0 = gr.udp_source(gr.sizeof_float*1, "127.0.0.1", 2001, 4, True, True) self.gr_udp_source_0 = gr.udp_source(gr.sizeof_float*1, "127.0.0.1", 2000, 4, True, True) self.gr_udp_sink_0_0 = gr.udp_sink(gr.sizeof_float*2048, "127.0.0.1", 2002, 11776, True) self.fft_vxx_0 = fft.fft_vcc(2048, True, (window.blackmanharris(1024)), True, 1) def _cur_freq_fine_probe(): while True: val = self.fine_cur.level() try: self.set_cur_freq_fine(val) except AttributeError, e: pass time.sleep(1.0/(10)) _cur_freq_fine_thread = threading.Thread(target=_cur_freq_fine_probe) _cur_freq_fine_thread.daemon = True _cur_freq_fine_thread.start() def _cur_freq_probe(): while True: val = self.signal_cur.level() try: self.set_cur_freq(val) except AttributeError, e: pass time.sleep(1.0/(10)) _cur_freq_thread = threading.Thread(target=_cur_freq_probe) _cur_freq_thread.daemon = True _cur_freq_thread.start() self.blocks_nlog10_ff_0 = blocks.nlog10_ff(1, 2048, 0) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(2048) self.blks2_stream_to_vector_decimator_0 = blks2.stream_to_vector_decimator( item_size=gr.sizeof_gr_complex, sample_rate=samp_rate, vec_rate=25, vec_len=2048, ) ################################################## # Connections ################################################## self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.blks2_stream_to_vector_decimator_0, 0), (self.fft_vxx_0, 0)) self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_nlog10_ff_0, 0)) self.connect((self.rtlsdr_source_c_0, 0), (self.blks2_stream_to_vector_decimator_0, 0)) self.connect((self.gr_udp_source_0_0, 0), (self.fine_cur, 0)) self.connect((self.gr_udp_source_0, 0), (self.signal_cur, 0)) self.connect((self.blocks_nlog10_ff_0, 0), (self.gr_udp_sink_0_0, 0))