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():
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)
