def main(): gr.enable_realtime_scheduling() parser = OptionParser(option_class=eng_option, conflict_handler="resolve") (options, args) = parser.parse_args () d = {'verbose': True, 'samples_per_symbol': 2, 'usrpx': None, 'excess_bw': 0.34999999999999998, 'fusb_block_size': 0, 'log': False, 'costas_alpha': 0.14999999999999999, 'bitrate': 100000.0, 'decim': DECIM, 'omega_relative_limit': 0.0050000000000000001, 'fusb_nblocks': 0, 'which': 0, 'rx_subdev_spec': None, 'freq_error': 0.0, 'lo_offset': None, 'modulation': 'gmsk', 'gain_mu': None, 'interface': 'eth0', 'freq': None, 'rx_freq': 2.475e9, 'rx_gain': RXGAIN, 'tx_freq': 2440000000.0, 'mu': 0.5, 'mac_addr': '', 'show_rx_gain_range': True, 'gray_code': True, 'tx_subdev_spec' : None, 'tx_gain' : None, 'show_tx_gain_range': False} for i, j in d.items(): setattr(options, i, j) u = usrp_options.create_usrp_source(options) adc_rate = u.adc_rate() if options.verbose: print 'USRP Source:', u (_bitrate, _samples_per_symbol, _decim) = \ pick_rx_bitrate(options.bitrate, 2, \ options.samples_per_symbol, options.decim, adc_rate, \ u.get_decim_rates()) u.set_decim(_decim) if not u.set_center_freq(options.rx_freq): print "Failed to set Rx frequency to %s" % (eng_notation.num_to_str(options.rx_freq)) raise ValueError, eng_notation.num_to_str(options.rx_freq) tb = gr.top_block() dst = gr.vector_sink_s () dump = gr.file_sink(gr.sizeof_gr_complex, 'packet.dat') tb.connect(u, dump) tb.run()
def main(): gr.enable_realtime_scheduling() tb = gr.top_block () src = gr.file_source(gr.sizeof_gr_complex, "transmit-data.dat", True) parser = OptionParser(option_class=eng_option, conflict_handler="resolve") (options, args) = parser.parse_args () d = {'verbose': True, 'discontinuous': False, 'samples_per_symbol': 2, 'usrpx': None, 'interp': INTERP, 'fusb_block_size': 0, 'megabytes': 1.0, 'rx_freq': 2.475e9, 'size': 1500, 'show_tx_gain_range': False, 'log': False, 'tx_subdev_spec': None, 'fusb_nblocks': 0, 'lo_offset': None, 'tx_gain': TXGAIN, 'which': 0, 'modulation': 'gmsk', 'excess_bw': 0.34999999999999998, 'bt': 0.34999999999999998, 'interface': 'eth0', 'freq': None, 'bitrate': 100000.0, 'from_file': None, 'tx_freq': 2475000000.0, 'mac_addr': '', 'tx_amplitude': 0.1, 'gray_code': True} for i, j in d.items(): setattr(options, i, j) u = usrp_options.create_usrp_sink(options) dac_rate = u.dac_rate() if options.verbose: print 'USRP Sink:', u (_bitrate, _samples_per_symbol, _interp) = \ pick_tx_bitrate(options.bitrate, 2, \ options.samples_per_symbol, options.interp, dac_rate, \ u.get_interp_rates()) u.set_interp(_interp) u.set_auto_tr(True) if not u.set_center_freq(options.tx_freq): print "Failed to set Rx frequency to %s" % (eng_notation.num_to_str(options.tx_freq)) raise ValueError, eng_notation.num_to_str(options.tx_freq) m = gr.multiply_const_cc(CONSTANT) tb.connect(src, m, u) tb.run()
def main(top_block_cls=gfsk_tx_1U, options=None): if options is None: options, _ = argument_parser().parse_args() if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." from distutils.version import StrictVersion if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"): style = gr.prefs().get_string('qtgui', 'style', 'raster') Qt.QApplication.setGraphicsSystem(style) qapp = Qt.QApplication(sys.argv) tb = top_block_cls(baudrate=options.baudrate, default_attenuation=options.default_attenuation, default_dev=options.default_dev, default_input=options.default_input, default_ip=options.default_ip, default_port=options.default_port, freq=options.freq, samp_rate_tx=options.samp_rate_tx, sdr_dev=options.sdr_dev) tb.start() tb.show() def quitting(): tb.stop() tb.wait() qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting) qapp.exec_()
def main(top_block_cls=SNREstimationLS_Tone, options=None): if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." from distutils.version import StrictVersion if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"): style = gr.prefs().get_string('qtgui', 'style', 'raster') Qt.QApplication.setGraphicsSystem(style) qapp = Qt.QApplication(sys.argv) tb = top_block_cls() tb.start() tb.show() #snrestimatefilename = "SNREstimationLeastSquaresFromTone.py" #commandval = 'sshpass -v -p \'123456789\' sudo python3 ' + snrestimatefilename + ' ' + filelocation + filename #time.sleep(1) #os.system(commandval) #print('sleeping ten seconds') #time.sleep(10) def quitting(): tb.stop() tb.wait() qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting) qapp.exec_()
def main(top_block_cls=fm_recv, options=None): if options is None: options, _ = argument_parser().parse_args() if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." from distutils.version import StrictVersion if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"): style = gr.prefs().get_string('qtgui', 'style', 'raster') Qt.QApplication.setGraphicsSystem(style) qapp = Qt.QApplication(sys.argv) tb = top_block_cls(audio_device=options.audio_device, decimation=options.decimation, fm_station=options.fm_station, hostname=options.hostname, uri=options.uri) tb.start() tb.show() def quitting(): tb.stop() tb.wait() qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting) qapp.exec_()
def __init__(self, cfg): gr.top_block.__init__(self) self.logger = logging.getLogger("gr-analyzer.top_block") # Use 2 copies of the configuration: # cgf - settings that matches the current state of the flowgraph # pending_cfg - requested config changes that will be applied during # the next run of configure self.cfg = cfg self.pending_cfg = copy(self.cfg) if cfg.realtime: # Attempt to enable realtime scheduling r = gr.enable_realtime_scheduling() if r != gr.RT_OK: self.logger.warning("failed to enable realtime scheduling") try: self.usrp = usrp(cfg) except RuntimeError as err: print("Error initializing USRP." + str(err), file=sys.stderr) sys.exit(0) # The main loop blocks at the end of the loop until either continuous # or single run mode is set. self.continuous_run = threading.Event() self.single_run = threading.Event() self.plot_iface = gui.plot_interface(self) self.rebuild_flowgraph = False self.configure(initial=True)
def main(top_block_cls=ndr_qt_demo_gui, options=None): if options is None: options, _ = argument_parser().parse_args() if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." from distutils.version import StrictVersion if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"): style = gr.prefs().get_string('qtgui', 'style', 'raster') Qt.QApplication.setGraphicsSystem(style) qapp = Qt.QApplication(sys.argv) tb = top_block_cls(basePort=options.basePort, dataPort=options.dataPort, hostnameOrDevice=options.hostnameOrDevice, ifname=options.ifname, radioType=options.radioType, udpPortOrBaudrate=options.udpPortOrBaudrate, verbose=options.verbose, vitaLevel=options.vitaLevel, wbfftRate=options.wbfftRate, wbfftSize=options.wbfftSize, wideband2=options.wideband2) tb.start() tb.show() def quitting(): tb.stop() tb.wait() qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting) qapp.exec_()
def __init__(self, midFreq, fft_len, occupied_len, cp_len, inter): if midFreq == None or fft_len == None or \ occupied_len == None or cp_len == None: print 'param is not ok!' return args = ['--tx-amplitude', '5000', '-i', str(inter), '-T', 'B', '-v'] args.append('-f') args.append(str(midFreq)) args.append('--fft-length') args.append(str(fft_len)) args.append('--occupied-tones') args.append(str(occupied_len)) args.append('--cp-length') args.append(str(cp_len)) parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") my_top_block.add_options(parser, expert_grp) transmit_path.add_options(parser, expert_grp) blks2.ofdm_mod.add_options(parser, expert_grp) blks2.ofdm_demod.add_options(parser, expert_grp) fusb_options.add_options(expert_grp) (options, args) = parser.parse_args(args) self.tb = my_top_block(options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print 'Warning: failed to enable realtime scheduling' self.tb.start() print 'tx init ok!'
def main(): global n_rcvd, n_right n_rcvd = 0 n_right = 0 def rx_callback_pkt(ok, payload, chan_num): global n_rcvd, n_right n_rcvd += 1 if ok: n_right += 1 (pktno, ) = struct.unpack('!H', payload[0:2]) print "ok = %5r pktno = %4d len(payload) = %4d %d/%d" % ( ok, pktno, len(payload), n_rcvd, n_right) print " payload: " + str(map(hex, map(ord, payload))) print " ------------------------" sys.stdout.flush() parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") oqpsk_rx_graph.add_options(parser, expert_grp) (options, args) = parser.parse_args() r = gr.enable_realtime_scheduling() if r == gr.RT_OK: print "Enabled Realtime" else: print "Failed to enable Realtime" tb = oqpsk_rx_graph(options, rx_callback_pkt) tb.start() tb.wait()
def main(): global n_rcvd, n_right n_rcvd = 0 n_right = 0 def rx_callback(ok, payload): global n_rcvd, n_right (pktno,) = struct.unpack('!H', payload[0:2]) # Xu: Calculate raw BER CalcBER(payload[2:]) n_rcvd += 1 if ok: n_right += 1 print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % ( ok, pktno, n_rcvd, n_right) demods = digital.modulation_utils.type_1_demods() # Create Options Parser: parser = OptionParser (option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-m", "--modulation", type="choice", choices=demods.keys(), default='psk', help="Select modulation from: %s [default=%%default]" % (', '.join(demods.keys()),)) parser.add_option("","--from-file", default=None, help="input file of samples to demod") receive_path.add_options(parser, expert_grp) uhd_receiver.add_options(parser) for mod in demods.values(): mod.add_options(expert_grp) (options, args) = parser.parse_args () if len(args) != 0: parser.print_help(sys.stderr) sys.exit(1) if options.from_file is None: if options.rx_freq is None: sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") parser.print_help(sys.stderr) sys.exit(1) # build the graph tb = my_top_block(demods[options.modulation], rx_callback, options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: Failed to enable realtime scheduling." tb.start() # start flow graph tb.wait() # wait for it to finish
def main(top_block_cls=VHF_multi_mode_transmitter, options=None): if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." tb = top_block_cls() tb.Start(True) tb.Wait()
def main(): # Create Options Parser: usage = "benchmack_add_channel.py [options] <input file> <output file>" parser = OptionParser(usage=usage, option_class=eng_option, conflict_handler="resolve") parser.add_option( "-n", "--snr", type="eng_float", default=30, help="set the SNR of the channel in dB [default=%default]" ) parser.add_option( "", "--seed", action="store_true", default=False, help="use a random seed for AWGN noise [default=%default]" ) parser.add_option( "-f", "--frequency-offset", type="eng_float", default=0, help="set frequency offset introduced by channel [default=%default]", ) parser.add_option( "-t", "--time-offset", type="eng_float", default=1.0, help="set timing offset between Tx and Rx [default=%default]", ) parser.add_option( "-p", "--phase-offset", type="eng_float", default=0, help="set phase offset (in degrees) between Tx and Rx [default=%default]", ) parser.add_option( "-m", "--use-multipath", action="store_true", default=False, help="Use a multipath channel [default=%default]" ) parser.add_option( "", "--tx-amplitude", type="eng_float", default=1.0, help="tell the simulator the signal amplitude [default=%default]", ) (options, args) = parser.parse_args() if len(args) != 2: parser.print_help(sys.stderr) sys.exit(1) ifile = args[0] ofile = args[1] # build the graph tb = my_top_block(ifile, ofile, options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: Failed to enable realtime scheduling." tb.start() # start flow graph tb.wait() # wait for it to finish
def __init__(self,Freq): global parser parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-s", "--size", type="eng_float", default=1024, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("","--from-file", default=None, help="use file for packet contents") parser.add_option("-e", "--interface", type="string", default="eth0", help="Select ethernet interface. Default is eth0") parser.add_option("-m", "--MAC_addr", type="string", default="", help="Select USRP2 by its MAC address.Default is auto-select") parser.add_option("-j", "--start", type="eng_float", default=1e7, help="Start ferquency [default = %default]") parser.add_option("-k", "--stop", type="eng_float", default=1e8,help="Stop ferquency [default = %default]") parser.add_option("", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS", help="time to delay (in seconds) after changing frequency[default=%default]") parser.add_option("", "--dwell-delay", type="eng_float",default=2e-3, metavar="SECS", help="time to dwell (in seconds) at a given frequncy[default=%default]") parser.add_option("-G", "--gain", type="eng_float", default=None,help="set gain in dB (default is midpoint)") parser.add_option("-s", "--fft-size", type="int", default=256, help="specify number of FFT bins [default=%default]")# changed default value(256) parser.add_option("-d", "--decim", type="intx", default=4, help="set decimation to DECIM [default=%default]") # changed default value(16) parser.add_option("-i", "--input_file", default="", help="radio input file",metavar="FILE") parser.add_option("-S", "--sense-bins", type="int", default=128, help="set number of bins in the OFDM block [default=%default]") usrp_transmit_path.add_options(parser, expert_grp) ofdm.ofdm_mod.add_options(parser, expert_grp) (self.options, self.args) = parser.parse_args () if len(self.args) != 0: parser.print_help() sys.exit(1) if self.options.tx_freq is None: sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") parser.print_help(sys.stderr) sys.exit(1) self.options.tx_freq=Freq.value self.tb = transmit(self.options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling"
def main(top_block_cls=pager_6ch_decode, options=None): if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." tb = top_block_cls() tb.Start(True) tb.Wait()
def main(): parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-b", "--burst-length", type="int", default=50, help="Number of packets in each burst") parser.add_option("-t", "--sleep-time", type="int", default=100, help="sleep time (msec) between the bursts") parser.add_option("-s", "--server", type="string", default='idb2', help="server hosting the packet server/sink") parser.add_option("-o", "--port", type="int", default='5123', help="tcp port on the packet server/sink serving packets") parser.add_option("","--to-file", default=None, help="Output file for modulated samples") uhd_transmitter.add_options(parser) (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() sys.exit(1) # build the graph tb = my_top_block(options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" tb.start() # start flow graph tb.wait() # wait for it to finish
def main(top_block_cls=classifier_test, options=None): if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." tb = top_block_cls() tb.start() tb.wait()
def main(top_block_cls=ReceiveDataAutomated, options=None): if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." tb = top_block_cls() tb.start() tb.wait()
def main(top_block_cls=NBFM, options=None): if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." tb = top_block_cls() tb.Start(True) tb.Wait()
def main(): global n_rcvd, n_right n_rcvd = 0 n_right = 0 def rx_callback(ok, payload): global n_rcvd, n_right n_rcvd += 1 if len(payload) > 2: (pktno,) = struct.unpack('!H', payload[0:2]) if ok: n_right += 1 else: pktno = -1 print "ok: %r \t pktno: %d \t n_rcvd: %d \t n_right: %d" % (ok, pktno, n_rcvd, n_right) if 0: printlst = list() for x in payload[2:]: t = hex(ord(x)).replace('0x', '') if(len(t) == 1): t = '0' + t printlst.append(t) printable = ''.join(printlst) print printable print "\n" parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous") parser.add_option("","--from-file", default=None, help="input file of samples to demod") receive_path.add_options(parser, expert_grp) uhd_receiver.add_options(parser) digital.ofdm_demod.add_options(parser, expert_grp) (options, args) = parser.parse_args () if options.from_file is None: if options.rx_freq is None: sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") parser.print_help(sys.stderr) sys.exit(1) # build the graph tb = my_top_block(rx_callback, options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" tb.start() # start flow graph tb.wait() # wait for it to finish
def main(top_block_cls=PlayToneFromFIle1, options=None): if gr.enable_realtime_scheduling() != gr.RT_OK: print("Error: failed to enable real-time scheduling.") tb = top_block_cls() tb.start() tb.wait()
def postProcessing(self, inSampRate, dxcFreq, sampRate): # xlating if dxcFreq != 0: xlateFilterTaps = firdes.low_pass(1, sampRate, sampRate / 2, sampRate / 10, firdes.WIN_HAMMING, 6.76) self.xlatingFilter = gr.freq_xlating_fir_filter_ccc(1, (xlateFilterTaps), dxcFreq, sampRate) print "i: xlating filter fixed to " + str(dxcFreq) else: self.xlatingFilter = gr.multiply_const_vcc((1, )) print "i: xlating filter not needed" # pfb resampler self.resamplerFactor = sampRate / inSampRate nphases = 32 frac_bw = 0.45 rs_taps = firdes.low_pass(nphases, nphases, frac_bw, 0.5 - frac_bw) self.resampler = blks2.pfb_arb_resampler_ccf(self.resamplerFactor, (rs_taps), nphases) print "i: re-sampler relation new_freq/old_freq = " + str(self.resamplerFactor) #EO instance variables self.isRTEnable = gr.enable_realtime_scheduling() if self.isRTEnable == gr.RT_OK: print "i: realtime enable: True" else: print "i: realtime enable: False" # Connections self.connect((self, 0), (self.resampler, 0), (self.xlatingFilter, 0), (self.tx, 0))
def main(top_block_cls=benchmark_copy, options=None): parser = ArgumentParser(description='Run a flowgraph iterating over parameters for benchmarking') parser.add_argument('--rt_prio', help='enable realtime scheduling', action='store_true') parser.add_argument('--samples', type=int, default=1e6) parser.add_argument('--veclen', type=int, default=128) parser.add_argument('--nblocks', type=int, default=4) parser.add_argument('--load', type=int, default=1) parser.add_argument('--memmodel', type=int, default=0) args = parser.parse_args() print(args) if args.rt_prio and gr.enable_realtime_scheduling() != gr.RT_OK: print("Error: failed to enable real-time scheduling.") tb = top_block_cls(args) def sig_handler(sig=None, frame=None): tb.stop() tb.wait() sys.exit(0) signal.signal(signal.SIGINT, sig_handler) signal.signal(signal.SIGTERM, sig_handler) print("starting ...") startt = time.time() tb.start() tb.wait() endt = time.time() # print(f'[PROFILE_VALID]{tb.snk.valid()}[PROFILE_VALID]') print(f'[PROFILE_TIME]{endt-startt}[PROFILE_TIME]')
def main(): import signal def quit_gracefully(signum, frame): raise KeyboardInterrupt, "Signal handler" signal.signal(signal.SIGINT, quit_gracefully) parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") my_top_block.add_options(parser, expert_grp) (options, args) = parser.parse_args () # build the graph tb = my_top_block(options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" if tb.scope is not None: tb.scope() else: try: tb.start() # start flow graph except KeyboardInterrupt: tb.stop() tb.wait() # wait for it to finish
def main(top_block_cls=benchmark_fft, options=None): parser = ArgumentParser(description='Benchmark series of cuFFT blocks') parser.add_argument('--rt_prio', help='enable realtime scheduling', action='store_true') parser.add_argument('--samples', type=int, default=2e8) parser.add_argument('--fftsize', type=int, default=1) parser.add_argument('--batchsize', type=int, default=1) parser.add_argument('--nblocks', type=int, default=1) parser.add_argument('--memmodel', type=int, default=0) args = parser.parse_args() print(args) if args.rt_prio and gr.enable_realtime_scheduling() != gr.RT_OK: print("Error: failed to enable real-time scheduling.") tb = top_block_cls(args) def sig_handler(sig=None, frame=None): tb.stop() tb.wait() sys.exit(0) signal.signal(signal.SIGINT, sig_handler) signal.signal(signal.SIGTERM, sig_handler) print("starting ...") startt = time.time() tb.start() tb.wait() endt = time.time() print(f'[PROFILE_TIME]{endt-startt}[PROFILE_TIME]')
def main(top_block_cls=electrosense_final, options=None): if options is None: options = argument_parser().parse_args() if gr.enable_realtime_scheduling() != gr.RT_OK: print("Error: failed to enable real-time scheduling.") if StrictVersion("4.5.0") <= StrictVersion( Qt.qVersion()) < StrictVersion("5.0.0"): style = gr.prefs().get_string('qtgui', 'style', 'raster') Qt.QApplication.setGraphicsSystem(style) qapp = Qt.QApplication(sys.argv) tb = top_block_cls(end_f=options.end_f, start_f=options.start_f) tb.start() tb.show() def sig_handler(sig=None, frame=None): Qt.QApplication.quit() signal.signal(signal.SIGINT, sig_handler) signal.signal(signal.SIGTERM, sig_handler) timer = Qt.QTimer() timer.start(500) timer.timeout.connect(lambda: None) def quitting(): tb.stop() tb.wait() qapp.aboutToQuit.connect(quitting) qapp.exec_()
def main(): import signal def quit_gracefully(signum, frame): raise KeyboardInterrupt, "Signal handler" signal.signal(signal.SIGINT, quit_gracefully) parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") my_top_block.add_options(parser, expert_grp) (options, args) = parser.parse_args() # build the graph tb = my_top_block(options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" if tb.scope is not None: tb.scope() else: try: tb.start() # start flow graph except KeyboardInterrupt: tb.stop() tb.wait() # wait for it to finish
def main(top_block_cls=top_block, options=None): if options is None: options, _ = argument_parser().parse_args() if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." from distutils.version import StrictVersion if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"): style = gr.prefs().get_string('qtgui', 'style', 'raster') Qt.QApplication.setGraphicsSystem(style) qapp = Qt.QApplication(sys.argv) tb = top_block_cls(MCS=options.MCS, N_CCE=options.N_CCE, N_dl_prb=options.N_dl_prb, RB_start_UE_1=options.RB_start_UE_1, RB_start_UE_2=options.RB_start_UE_2, aggregation1=options.aggregation1, aggregation2=options.aggregation2, allocation_len_UE_1=options.allocation_len_UE_1, allocation_len_UE_2=options.allocation_len_UE_2, cfi_val=options.cfi_val, n_pdcch=options.n_pdcch) tb.start() tb.show() def quitting(): tb.stop() tb.wait() qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting) qapp.exec_()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-s', '--sample-rate', type=float, default=40e6) parser.add_argument('-f', '--frequency', type=float, default=940e6) parser.add_argument('-g', '--gain', type=float, default=40) parser.add_argument('-n', '--fft-size', type=int, default=4096) parser.add_argument('-r', '--frame-rate', type=int, default=25) args = parser.parse_args() if gr.enable_realtime_scheduling() != gr.RT_OK or 0: print("Error: failed to enable real-time scheduling.") tb = fft_receiver(samp_rate=args.sample_rate, freq=args.frequency, gain=args.gain, fft_size=args.fft_size, framerate=args.frame_rate) tb.start() opts['center'] = args.frequency opts['span'] = args.sample_rate server = WSGIServer(("0.0.0.0", 8000), app, handler_class=WebSocketHandler) try: server.serve_forever() except Exception: sys.exit(0) tb.stop() tb.wait()
def __init__(self, rx, reader, tx): gr.top_block.__init__(self) samp_freq = (64 / dec_rate) * 1e6 amplitude = 33000 num_taps = int( 64000 / (dec_rate * up_link_freq * 2)) #Matched filter for 1/2 cycle taps = [complex(1, 1)] * num_taps print num_taps filt = gr.fir_filter_ccc(sw_dec, taps) to_mag = gr.complex_to_mag() amp = gr.multiply_const_cc(amplitude) c_gate = rfid.cmd_gate(dec_rate * sw_dec, reader.STATE_PTR) zc = rfid.clock_recovery_zc_ff(samples_per_pulse, 2) dummy = gr.null_sink(gr.sizeof_float) to_complex = gr.float_to_complex() r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" self.connect(rx, filt, to_mag, c_gate, zc, reader, amp, tx)
def __init__(self, rx, reader, tx): gr.top_block.__init__(self) samp_freq = (64 / dec_rate) * 1e6 amplitude = 33000 num_taps = int(64000 / (dec_rate * up_link_freq * 2)) #Matched filter for 1/2 cycle taps = [complex(1,1)] * num_taps print num_taps filt = gr.fir_filter_ccc(sw_dec, taps) to_mag = gr.complex_to_mag() amp = gr.multiply_const_cc(amplitude) c_gate = rfid.cmd_gate(dec_rate * sw_dec, reader.STATE_PTR) zc = rfid.clock_recovery_zc_ff(samples_per_pulse, 2); dummy = gr.null_sink(gr.sizeof_float) to_complex = gr.float_to_complex() r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" self.connect(rx, filt, to_mag, c_gate, zc, reader, amp, tx);
def main(): def send_pkt(payload='', eof=False): return tb.txpath.send_pkt(0xe5, struct.pack("HHHH", 0xFFFF,0xFFFF, 0x10, 0x10), payload, eof) def rx_callback(ok, payload): print "ok = %r, payload =%s "% (ok, payload) #construct options of modulation BPSK all transmission (options, args) = get_options() #Begin construction of the flow graph tb = my_top_block(options) #Allow a real time scheduling. It's possible just with root session r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" tb.start() #Begin the execution of flot graph #tb.Run() # With the graphical Sink #like in iee802.15.4 construct and send packets for i in range(10): print "envoi du message %d: "% (i+1,) send_pkt(struct.pack('9B', 0x1, 0x80, 0x80, 0xff, 0xff, 0x10, 0x0, 0x20, 0x0)) time.sleep(1) #wait transmission to finish tb.wait()
def parse_args(): # enable real time scheduling r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable real time scheduling" # parse parameters parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") expert_grp.add_option("-c", "--carrier_threshold", type="eng_float", default=meta_data.default_carrier_thredshold, help="set carrier detect threshold (dB) [default=%default]") parser.add_option("-i","--id", default=meta_data.default_id, help="id: check out meta_data.py also.") receive_path.add_options(parser, expert_grp) uhd_receiver.add_options(parser) digital.ofdm_demod.add_options(parser, expert_grp) transmit_path.add_options(parser, expert_grp) digital.ofdm_mod.add_options(parser, expert_grp) uhd_transmitter.add_options(parser) (options, args) = parser.parse_args () if int(options.id) == meta_data.default_id: print int(options.id) sys.stderr.write("You must specify -i ID or --id ID\n") parser.print_help(sys.stderr) sys.exit(1) else: options.rx_freq = meta_data.channels_freq_table[meta_data.init_channel_num] * 1e9 options.tx_freq = meta_data.channels_freq_table[meta_data.init_channel_num] * 1e9 options.bandwidth = (meta_data.default_bandwidth * 10000000.0)/4 return options
def __init__(self, tx, zc, reader, rx, matched_filter, reader_monitor_cmd_gate, cr, tag_monitor, amplitude): gr.top_block.__init__(self) # ASK/PSK demodulators to_mag_L = gr.complex_to_mag() to_mag_R = gr.complex_to_mag() # Others blocks for Buettner's reader samp_freq = (64 / dec_rate) * 1e6 num_taps = int(64000 / (dec_rate * up_link_freq * 4)) taps = [complex(1, 1)] * num_taps filt = gr.fir_filter_ccc(sw_dec, taps) # Matched filter amp = gr.multiply_const_cc(amplitude) c_gate = rfid.cmd_gate(dec_rate * sw_dec, reader.STATE_PTR) # Null sink for terminating the Listener graph null_sink = gr.null_sink(gr.sizeof_float * 1) # Deinterleaver to separate FPGA channels di = gr.deinterleave(gr.sizeof_gr_complex) # Enable real-time scheduling r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" # Create flow-graph self.connect(rx, di) self.connect((di, 0), filt, to_mag_R, c_gate, zc, reader, amp, tx) self.connect((di, 1), matched_filter, to_mag_L, reader_monitor_cmd_gate, cr, tag_monitor, null_sink)
def main(): global n_rcvd, n_right n_rcvd = 0 n_right = 0 def rx_callback(ok, payload): global n_rcvd, n_right (pktno, ) = struct.unpack('!H', payload[0:2]) n_rcvd += 1 if ok: n_right += 1 # print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % ( # ok, pktno, n_rcvd, n_right) demods = digital.modulation_utils.type_1_demods() # Create Options Parser: parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option( "-m", "--modulation", type="choice", choices=demods.keys(), default='gfsk', #'psk', help="Select modulation from: %s [default=%%default]" % (', '.join(demods.keys()), )) # parser.add_option("","--from-file", default=None, # help="input file of samples to demod") receive_path.add_options(parser, expert_grp) uhd_receiver.add_options(parser) for mod in demods.values(): mod.add_options(expert_grp) (options, args) = parser.parse_args() if len(args) != 0: parser.print_help(sys.stderr) sys.exit(1) if options.from_file is None: if options.rx_freq is None: sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") parser.print_help(sys.stderr) sys.exit(1) # build the graph tb = my_top_block(demods[options.modulation], rx_callback, options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print("Warning: Failed to enable realtime scheduling.") tb.start() # start flow graph tb.wait() # wait for it to finish
def main(top_block_cls=signal_hunter_multi, options=None): if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." tb = top_block_cls() tb.Start(True) tb.Wait()
def __init__(self,Freq): global parser parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-s", "--size", type="eng_float", default=1024, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=10.0, help="set megabytes to transmit [default=%default]") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("","--from-file", default=None, help="use file for packet contents") parser.add_option("-e", "--interface", type="string", default="eth0", help="Select ethernet interface. Default is eth0") parser.add_option("-m", "--MAC_addr", type="string", default="", help="Select USRP2 by its MAC address.Default is auto-select") parser.add_option("-j", "--start", type="eng_float", default=1e7, help="Start ferquency [default = %default]") parser.add_option("-k", "--stop", type="eng_float", default=1e8,help="Stop ferquency [default = %default]") parser.add_option("", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS", help="time to delay (in seconds) after changing frequency[default=%default]") parser.add_option("", "--dwell-delay", type="eng_float",default=1e-3, metavar="SECS", help="time to dwell (in seconds) at a given frequncy[default=%default]") parser.add_option("-G", "--gain", type="eng_float", default=None,help="set gain in dB (default is midpoint)") parser.add_option("-s", "--fft-size", type="int", default=256, help="specify number of FFT bins [default=%default]")# changed default value(256) parser.add_option("-d", "--decim", type="intx", default=16, help="set decimation to DECIM [default=%default]") # changed default value(16) parser.add_option("-i", "--input_file", default="", help="radio input file",metavar="FILE") parser.add_option("-S", "--sense-bins", type="int", default=128, help="set number of bins in the OFDM block [default=%default]") usrp_transmit_path.add_options(parser, expert_grp) ofdm.ofdm_mod.add_options(parser, expert_grp) (self.options, self.args) = parser.parse_args () if len(self.args) != 0: parser.print_help() sys.exit(1) if self.options.tx_freq is None: sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") parser.print_help(sys.stderr) sys.exit(1) self.options.tx_freq=Freq.value self.tb = transmit(self.options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling"
def main(top_block_cls=benchmark_pfb_channelizer, options=None): parser = ArgumentParser(description='Run a flowgraph iterating over parameters for benchmarking') parser.add_argument('--rt_prio', help='enable realtime scheduling', action='store_true') parser.add_argument('--samples', type=int, default=1e8) parser.add_argument('--nchans', type=int, default=4) parser.add_argument('--attenuation', type=float, default=70) parser.add_argument('--buffer_size', type=int, default=8192) parser.add_argument('--cuda', action='store_true') args = parser.parse_args() print(args) if args.rt_prio and gr.enable_realtime_scheduling() != gr.RT_OK: print("Error: failed to enable real-time scheduling.") tb = top_block_cls(args) def sig_handler(sig=None, frame=None): tb.stop() tb.wait() sys.exit(0) signal.signal(signal.SIGINT, sig_handler) signal.signal(signal.SIGTERM, sig_handler) print("starting ...") startt = time.time() tb.start() tb.wait() endt = time.time() print(f'[PROFILE_TIME]{endt-startt}[PROFILE_TIME]')
def main (): def rx_callback(ok, payload, chan_num): # Output this packet in pcap format pcap_capture_time = time.time() pcap_capture_msec = math.modf(pcap_capture_time)[0] * 1e6 pcap_pkt_header = struct.pack('IIIIB', pcap_capture_time, pcap_capture_msec, len(payload)+1, len(payload)+1, chan_num) fout.write(pcap_pkt_header) fout.write(payload) fout.flush() parser = OptionParser (option_class=eng_option) parser.add_option ("-c", "--channel1", type="int", default=2475000000, help="First channel to capture on", metavar="FREQ") parser.add_option ("-f", "--filename", type="string", default="rx.dat", help="write data to FILENAME") parser.add_option ("-g", "--gain", type="eng_float", default=40, help="set Rx gain in dB [0,70]") parser.add_option ("-s", "--squelch", type="eng_float", default=-40.0, help="Set Squelch filter level") parser.add_option("-e", "--interface", type="string", default="eth0", help="select Ethernet interface, default is eth0") parser.add_option("-m", "--mac-addr", type="string", default="", help="select USRP by MAC address, default is auto-select") (options, args) = parser.parse_args () st1 = stats() st2 = stats() # Setup the libpcap output file fout = open(options.filename, "w") # Write the libpcap Global Header pcap_glob_head = struct.pack('IHHiIII', 0xa1b2c3d4, # Magic Number 2, # Major Version Number 4, # Minor Version Number 0, 0, 65535, 221) # Link Layer Type = 802.15.4 PHY Channel fout.write(pcap_glob_head) r = gr.enable_realtime_scheduling() if r == gr.RT_OK: print "Enabled Realtime" else: print "Failed to enable Realtime. Did you run as root?" tb = oqpsk_rx_graph(options, rx_callback) tb.start() tb.wait()
def __init__(self, top_block, gui, options, args, title, nstatus, start, realtime): wx.Frame.__init__(self, None, -1, title) self.top_block = top_block self.CreateStatusBar(nstatus) mainmenu = wx.MenuBar() self.SetMenuBar(mainmenu) menu = wx.Menu() item = menu.Append(200, 'E&xit', 'Exit Application') # FIXME magic ID self.Bind(wx.EVT_MENU, self.OnCloseWindow, item) mainmenu.Append(menu, "&File") self.Bind(wx.EVT_CLOSE, self.OnCloseWindow) # Create main panel, creates user GUI class with supplied parameters self.panel = top_panel(self, top_block, gui, options, args) vbox = wx.BoxSizer(wx.VERTICAL) vbox.Add(self.panel, 1, wx.EXPAND) self.SetSizer(vbox) self.SetAutoLayout(True) vbox.Fit(self) if realtime: if gr.enable_realtime_scheduling() != gr.RT_OK: self.SetStatusText("Failed to enable realtime scheduling") if start and self.top_block is not None: self.top_block.start()
def __init__ (self, top_block, gui, options, args, title, nstatus, start, realtime): wx.Frame.__init__(self, None, -1, title) self.top_block = top_block self.CreateStatusBar(nstatus) mainmenu = wx.MenuBar() self.SetMenuBar(mainmenu) menu = wx.Menu() item = menu.Append(200, 'E&xit', 'Exit Application') # FIXME magic ID self.Bind(wx.EVT_MENU, self.OnCloseWindow, item) mainmenu.Append(menu, "&File") self.Bind(wx.EVT_CLOSE, self.OnCloseWindow) # Create main panel, creates user GUI class with supplied parameters self.panel = top_panel(self, top_block, gui, options, args) vbox = wx.BoxSizer(wx.VERTICAL) vbox.Add(self.panel, 1, wx.EXPAND) self.SetSizer(vbox) self.SetAutoLayout(True) vbox.Fit(self) if realtime: if gr.enable_realtime_scheduling() != gr.RT_OK: self.SetStatusText("Failed to enable realtime scheduling") if start and self.top_block is not None: self.top_block.start()
def main(): def send_pkt(payload='', eof=False): return tb.txpath.send_pkt(payload, eof) parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-s", "--size", type="eng_float", default=400, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("","--from-file", default=None, help="use intput file for packet contents") parser.add_option("","--to-file", default=None, help="Output file for modulated samples") transmit_path.add_options(parser, expert_grp) digital.ofdm_mod.add_options(parser, expert_grp) uhd_transmitter.add_options(parser) (options, args) = parser.parse_args () # build the graph tb = my_top_block(options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" tb.start() # start flow graph # generate and send packets nbytes = int(1e6 * options.megabytes) n = 0 pktno = 0 pkt_size = int(options.size) while n < nbytes: if options.from_file is None: # data = (pkt_size - 2) * (pktno & 0xff) data = (pkt_size - 2) * 'a' else: data = source_file.read(pkt_size - 2) if data == '': break; payload = struct.pack('!H', pktno & 0xffff) + data send_pkt(payload) n += len(payload) # sys.stderr.write('.') if options.discontinuous and pktno % 5 == 4: time.sleep(1) pktno += 1 # print pktno, ' ' print('payload = ', payload) send_pkt(eof=True) tb.wait() # wait for it to finish
def main (): global n_rcvd, n_right n_rcvd = 0 n_right = 0 def rx_callback_pkt(ok, payload, chan_num): global n_rcvd, n_right n_rcvd += 1 if ok: n_right += 1 (pktno,) = struct.unpack('!H', payload[0:2]) print "ok = %5r pktno = %4d len(payload) = %4d %d/%d" % (ok, pktno, len(payload), n_rcvd, n_right) print " payload: " + str(map(hex, map(ord, payload))) print " ------------------------" sys.stdout.flush() parser = OptionParser (option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") oqpsk_rx_graph.add_options(parser, expert_grp) (options, args) = parser.parse_args () r= gr.enable_realtime_scheduling() if r == gr.RT_OK: print "Enabled Realtime" else: print "Failed to enable Realtime" tb = oqpsk_rx_graph(options, rx_callback_pkt) tb.start() tb.wait()
def main(top_block_cls=transmitter_OQPSK, options=None): if options is None: options, _ = argument_parser().parse_args() if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." from distutils.version import StrictVersion if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"): style = gr.prefs().get_string('qtgui', 'style', 'raster') Qt.QApplication.setGraphicsSystem(style) qapp = Qt.QApplication(sys.argv) tb = top_block_cls(num_messages=options.num_messages, pad=options.pad, preamble=options.preamble, tx_gain=options.tx_gain) tb.start() tb.show() def quitting(): tb.stop() tb.wait() qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting) qapp.exec_()
def main(): global n_rcvd, n_right n_rcvd = 0 n_right = 0 def rx_callback(ok, payload): global n_rcvd, n_right n_rcvd += 1 if ok: n_right += 1 tb.audio_tx.msgq().insert_tail(gr.message_from_string(payload)) print "ok = %r n_rcvd = %4d n_right = %4d" % ( ok, n_rcvd, n_right) demods = digital.modulation_utils.type_1_demods() # Create Options Parser: parser = OptionParser (option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-m", "--modulation", type="choice", choices=demods.keys(), default='gmsk', help="Select modulation from: %s [default=%%default]" % (', '.join(demods.keys()),)) parser.add_option("-O", "--audio-output", type="string", default="", help="pcm output device name. E.g., hw:0,0 or /dev/dsp") parser.add_option("","--from-file", default=None, help="input file of samples to demod") receive_path.add_options(parser, expert_grp) uhd_receiver.add_options(parser) for mod in demods.values(): mod.add_options(expert_grp) parser.set_defaults(bitrate=50e3) # override default bitrate default (options, args) = parser.parse_args () if len(args) != 0: parser.print_help(sys.stderr) sys.exit(1) if options.from_file is None: if options.rx_freq is None: sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") parser.print_help(sys.stderr) sys.exit(1) # build the graph tb = my_top_block(demods[options.modulation], rx_callback, options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: Failed to enable realtime scheduling." tb.run()
def main_loop(sound_obj,count,Freq): global n_rcvd, n_right ,data n_rcvd = 0 n_right = 0 data="" global packet_file packet_file = open('/usr/local/share/gnuradio/examples/audio/sound','a') def rx_callback(ok, payload): global n_rcvd, n_right global data count.value=1 #reset the counter n_rcvd += 1 (pktno,) = struct.unpack('!H', payload[0:2]) if ok: n_right += 1 #if pktno > 19: #print "writing to file\n" #if (len(data)<1024): #print "length of payload",len(payload) #data=data+payload[2:] #else: #data_buff=data[1024:] print "length of data",len(payload[2:]) sound_obj.sound_sink.write(payload[2:]) #data=data_buff print "ok: %r \t pktno: %d \t n_rcvd: %d \t n_right: %d" % (ok, pktno, n_rcvd, n_right) parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("", "--snr", type="eng_float", default=30, help="set the SNR of the channel in dB [default=%default]") usrp_receive_path.add_options(parser, expert_grp) ofdm.ofdm_demod.add_options(parser, expert_grp) (options, args) = parser.parse_args () if len(args) != 0: parser.print_help(sys.stderr) sys.exit(1) options.rx_freq=Freq.value if options.rx_freq is None: sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") parser.print_help(sys.stderr) sys.exit(1) tb = my_top_block(rx_callback, options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" tb.start() # start flow graph tb.wait() # wait for it to finish
def init(): if gr.enable_realtime_scheduling() != gr.RT_OK: print('Error: failed to enable realtime scheduling.') fcd = top_block.top_block() server_thd = FcdServerThread(fcd, fcd_write) server_thd.daemon = True server_thd.start() fcd.Start(True) fcd.Wait()
def main(top_block_cls=pager_6ch_decode, options=None): if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." queue = gr.msg_queue() tb = top_block_cls(queue) runner = pager.queue_runner(queue) tb.Start(True) tb.Wait()
def main(): def send_pkt(payload='', eof=False): return tb.txpath.send_pkt(payload, eof) parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-s", "--size", type="eng_float", default=400, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("","--from-file", default=None, help="use intput file for packet contents") parser.add_option("","--to-file", default=None, help="Output file for modulated samples") transmit_path.add_options(parser, expert_grp) digital.ofdm_mod.add_options(parser, expert_grp) uhd_transmitter.add_options(parser) (options, args) = parser.parse_args () # build the graph tb = my_top_block(options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" tb.start() # start flow graph # generate and send packets nbytes = int(1e6 * options.megabytes) n = 0 pktno = 0 pkt_size = int(options.size) while n < nbytes: if options.from_file is None: data = (pkt_size - 2) * chr(pktno & 0xff) else: data = source_file.read(pkt_size - 2) if data == '': break; payload = struct.pack('!H', pktno & 0xffff) + data send_pkt(payload) n += len(payload) sys.stderr.write('.') if options.discontinuous and pktno % 5 == 4: time.sleep(1) pktno += 1 send_pkt(eof=True) tb.wait() # wait for it to finish
def main(): global file def send_pkt(payload="", eof=False): return tb.txpath.send_pkt(payload, eof) mods = digital.modulation_utils.type_1_mods() parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option( "-m", "--modulation", type="choice", choices=mods.keys(), default="psk", help="Select modulation from :%s [default=%%default]" % (", ".join(mods.keys()),), ) parser.add_option("-s", "--size", type="eng_float", default=1500, help="set packet size [default=%default]") parser.add_option("", "--from-file", default=None, help="Use input file for packet contents") parser.add_option("", "--samples-file", default=None, help="Output file for modulated samples") transmit_path.add_options(parser, expert_grp) for mod in mods.values(): mod.add_options(expert_grp) (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) if options.from_file is not None: source_file = open(options.from_file, "r") tb = loop_top_block(mods[options.modulation], options) # do we need to do this for our test bench? r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" tb.start() pkt_size = int(options.size) while True: data = source_file.read(pkt_size) if data == "": break # payload = struct.pack('!H', pktno & 0xffff) + data payload = data send_pkt(payload)
def main(): global n_rcvd, n_right n_rcvd = 0 n_right = 0 def rx_callback(ok, payload): global n_rcvd, n_right (pktno,) = struct.unpack("!H", payload[0:2]) n_rcvd += 1 if ok: n_right += 1 print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % (ok, pktno, n_rcvd, n_right) # print "payload ", payload demods = modulation_utils.type_1_demods() # Create Options Parser: parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option( "-m", "--modulation", type="choice", choices=demods.keys(), default="gmsk", #'dbpsk', need to add SNR stuff help="Select modulation from: %s [default=%%default]" % (", ".join(demods.keys()),), ) usrp_receive_path2.add_options(parser, expert_grp) for mod in demods.values(): mod.add_options(expert_grp) (options, args) = parser.parse_args() if len(args) != 0: parser.print_help(sys.stderr) sys.exit(1) if options.rx_freq is None: sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") parser.print_help(sys.stderr) sys.exit(1) # build the graph tb = my_top_block(demods[options.modulation], rx_callback, options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: Failed to enable realtime scheduling." tb.start() # start flow graph tb.wait() # wait for it to finish
def main(top_block_cls=signal_hunter_multi, options=None): if gr.enable_realtime_scheduling() != gr.RT_OK: print "Error: failed to enable real-time scheduling." queue = gr.msg_queue() tb = top_block_cls(queue) runner = pager.queue_runner(queue) tb.Start(True) tb.Wait()
def main(): global n_rcvd, n_right n_rcvd = 0 n_right = 0 def rx_callback(ok, payload): global n_rcvd, n_right n_rcvd += 1 (pktno,) = struct.unpack('!H', payload[0:2]) if ok: n_right += 1 print "ok: %r \t pktno: %d \t n_rcvd: %d \t n_right: %d" % (ok, pktno, n_rcvd, n_right) if 0: printlst = list() for x in payload[2:]: t = hex(ord(x)).replace('0x', '') if(len(t) == 1): t = '0' + t printlst.append(t) printable = ''.join(printlst) print printable print "\n" parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous") transceiver.add_options(parser, expert_grp) (options, args) = parser.parse_args() tr = transceiver(rx_callback, options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" tr.start() #nbytes = int(1e6) #n = 0 #pkt_size = 400 #pktno = 0 #while n < nbytes: # tr.send_pkt(struct.pack('!H', pktno) + (pkt_size - 2) * chr(pktno & 0xff)) # pktno += 1 # n += 1 # if pktno % 5 == 0: # print '.', #time.sleep(1000) #send_pkt('',True) tr.wait()
def main(): parser = OptionParser(conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") ofdm_mrrc_benchmark.add_options(parser, expert_grp) transmit_path.add_options(parser, expert_grp) receive_path.add_options(parser, expert_grp) fusb_options.add_options(expert_grp) parser.add_option( "-c", "--cfg", action="store", type="string", default=None, help="Specifiy configuration file, default: none", config="false" ) (options, args) = parser.parse_args() if options.cfg is not None: (options,args) = parser.parse_args(files=[options.cfg]) print "Using configuration file %s" % ( options.cfg ) benchmark = ofdm_mrrc_benchmark(options) runtime = benchmark r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Couldn't enable realtime scheduling" else: print "Enabled realtime scheduling" try: if options.dot_graph: string_benchmark = runtime.dot_graph() filetx = os.path.expanduser('benchmark_mrrc_ofdm.dot') dot_file = open(filetx,'w') dot_file.write(string_benchmark) dot_file.close() runtime.run() #runtime.start() try: tx.txpath._control._id_source.ready() except: pass except KeyboardInterrupt: runtime.stop() runtime.wait() if options.measure: print "min",tx.m.get_min() print "max",tx.m.get_max() print "avg",tx.m.get_avg()
def setup_flowgraph(self): options = self.options # Attempt to enable realtime scheduling if options.realtime: r = gr.enable_realtime_scheduling() if r == gr.RT_OK: options.realtime = True print >> sys.stderr, "Realtime scheduling ENABLED" else: options.realtime = False print >> sys.stderr, "Realtime scheduling FAILED" self.setup_timing() # Setup our input source if options.inputfile: self.using_usrp = False print >> sys.stderr, "Reading data from: " + options.inputfile self.source = gr.file_source(gr.sizeof_gr_complex, options.inputfile, options.fileloop) else: self.using_usrp = True #self.setup_usrp() self.setup_filter() #create a tuner callback self.mean_offset = 0.0 #this is set by tuner callback self.burst_cb = burst_callback(self) # Setup flow based on decoder selection # if options.decoder.count("c"): self.setup_c_flowgraph() # elif options.decoder.count("f"): # self.setup_f_flowgraph() self.configure_burst_decoder() #Hookup a vector-stream converter if we want burst output if self.scopes.count("b") or options.outputfile: self.v2s = gr.vector_to_stream(gr.sizeof_float,142) #burst output is 142 (USEFUL_BITS) self.connect(self.burst, self.v2s) else: self.burst_sink = gr.null_sink(gr.sizeof_float) self.v2s = gr.vector_to_stream(gr.sizeof_float,142) #burst output is 142 (USEFUL_BITS) self.connect(self.burst, self.v2s) self.connect(self.v2s, self.burst_sink) #Output file if options.outputfile: self.filesink = gr.file_sink(gr.sizeof_float, options.outputfile) self.connect(self.v2s, self.filesink)
def main(): parser = OptionParser(option_class=eng_option, conflict_handler="resolve") parser.add_option("", "--tx-freq", type="eng_float", default=900e6, help="set receive frequency to FREQ [default=%default]", metavar="FREQ") parser.add_option("", "--rx-freq", type="eng_float", default=900e6, help="set receive frequency to FREQ [default=%default]", metavar="FREQ") parser.add_option("", "--sample-rate", type="eng_float", default=10e6, help="sample rate [default=%default]") parser.add_option("-s", "--size", type="eng_float", default=100, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser.add_option("", "--ack-timeout", type="int", default=500, help="set ack timeout, in milliseconds [default=%default]") parser.add_option("", "--tx-gain", type="eng_float", default=25, help="set transmit gain in dB [default=%default]") parser.add_option("", "--rx-gain", type="eng_float", default=20, help="set receive gain in dB [default=%default]") parser.add_option("", "--probe-threshold", type="eng_float", default=10, help="probe threshold in dB [default=%default]") parser.add_option("", "--tx-addr", type="string", default="01:23:45:67:89:ab", help="sender address [default=%default]") parser.add_option("", "--rx-addr", type="string", default="ab:89:67:45:23:01", help="receiver address [default=%default]") parser.add_option("", "--max-attempts", type="int", default=100, help="max retransmit attempts [default=%default]") parser.add_option("", "--receive-only", action="store_true", default=False, help="Only receive packets") parser.add_option("", "--debug", action="store_true", default=False, help="debug") (options, args) = parser.parse_args () # Attempt to enable realtime scheduling r = gr.enable_realtime_scheduling() if r == gr.RT_OK: realtime = True else: realtime = False print "Note: failed to enable realtime scheduling" # build the graph (PHY) tb = my_top_block(options) tb.start() # Start executing the flow graph (runs in separate threads) #tb.stop() # but if it does, tell flow graph to stop. tb.wait() # wait for it to finish
def test_main(): if gr.enable_realtime_scheduling() != gr.RT_OK: print "Note: failed to enable realtime scheduling, continuing" # Grab command line options and create top block try: (options, args) = get_options() tb = top_block(options, args) except RuntimeError, e: print e sys.exit(1)