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 main():
parser = OptionParser(conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
rx_top_block.add_options(parser)
receive_path.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
(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)
tb = rx_top_block(options)
if options.dot_graph:
# write a dot graph of the flowgraph to file
dot_str = tb.dot_graph()
file_str = os.path.expanduser('rx_ofdm.dot')
dot_file = open(file_str, 'w')
dot_file.write(dot_str)
dot_file.close()
try:
tb.run()
except [[KeyboardInterrupt]]:
pass
def add_options(normal, expert):
"""
Adds usrp-specific options to the Options Parser
"""
add_freq_option(normal)
normal.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
help="select USRP Tx side A or B")
normal.add_option("-v", "--verbose", action="store_true", default=False)
expert.add_option("", "--tx-freq", type="eng_float", default=None,
help="set transmit frequency to FREQ [default=%default]", metavar="FREQ")
expert.add_option("-i", "--interp", type="intx", default=256,
help="set fpga interpolation rate to INTERP [default=%default]")
normal.add_option("-R", "--rx-subdev-spec", type="subdev", default=None,
help="select USRP Rx side A or B")
normal.add_option("", "--rx-gain", type="eng_float", default=None, metavar="GAIN",
help="set receiver gain in dB [default=midpoint]. See also --show-rx-gain-range")
normal.add_option("", "--show-rx-gain-range", action="store_true", default=False,
help="print min and max Rx gain available on selected daughterboard")
normal.add_option("-v", "--verbose", action="store_true", default=False)
expert.add_option("", "--rx-freq", type="eng_float", default=None,
help="set Rx frequency to FREQ [default=%default]", metavar="FREQ")
expert.add_option("-d", "--decim", type="intx", default=128,
help="set fpga decimation rate to DECIM [default=%default]")
expert.add_option("", "--snr", type="eng_float", default=30,
help="set the SNR of the channel in dB [default=%default]")
#other necessary options
transmit_path.add_options(normal, expert)
receive_path.add_options(normal, expert)
blks2.ofdm_mod.add_options(normal, expert)
blks2.ofdm_demod.add_options(normal, expert)
fusb_options.add_options(expert)
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():
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():
parser = OptionParser(conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
rx_top_block.add_options(parser)
receive_path.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
(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 )
tb = rx_top_block(options)
if options.dot_graph:
# write a dot graph of the flowgraph to file
dot_str = tb.dot_graph()
file_str = os.path.expanduser('rx_ofdm.dot')
dot_file = open(file_str,'w')
dot_file.write(dot_str)
dot_file.close()
try:
tb.run()
except [[KeyboardInterrupt]]:
pass
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():
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='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():
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("-s", "--server", default=None,
help="competition server IP address")
parser.add_option("", "--red", action="store_true", default=False,
help="red team")
parser.add_option("", "--blue", action="store_true", default=False,
help="blue team")
#parser.add_option("","--from-file", default=None,
# help="input file of samples to demod")
receive_path.add_options(parser, expert_grp)
osmo_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)
# Can specify one and only one team
if bool(options.red) == bool(options.blue):
sys.stderr.write("Which team are you on? Use --red or --blue\n")
sys.exit(1)
# Must specify an input file or radio frequency
#if options.from_file is None:
if options.rx_freq is None:
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
sys.stderr.write("Use --help to see all options\n")
sys.exit(1)
# Must specify a server
if options.server is None:
sys.stderr.write("You must specify -s ADDRESS or --server ADDRESS\n")
sys.exit(1)
# Strip out the differential option if dbpsk or dqpsk are selected explicitly
if (options.modulation == 'dqpsk' or options.modulation == 'dbpsk'):
del options.differential
# Fire it up
receiver = Receiver(demods[options.modulation], options)
receiver.print_info()
receiver.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
(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"
usage = "usage: %prog [options] host"
parser = OptionParser(usage=usage,
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")
my_top_block.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
blks2.ofdm_mod.add_options(parser, expert_grp)
blks2.ofdm_demod.add_options(parser, expert_grp)
(options, args) = parser.parse_args()
address = args[0]
# build the graph
tb = my_top_block(address, 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():
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")
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
print options
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():
source_file = open("sample_audio", 'r')
def send_pkt(payload='', eof=False):
(no,) = (struct.unpack('!H', payload[0:2]))
print "sending packet %4d " % (no)
return tb.txpath.send_pkt(payload, eof)
def rx_callback(ok, payload):
(no,) = (struct.unpack('!H', payload[0:2]))
print "ok = %5s pktno = %4d " % (
ok, no)
mods = digital.modulation_utils.type_1_mods()
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=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]")
transmit_path.add_options(parser, expert_grp)
uhd_transmitter.add_options(parser)
receive_path.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
for mod in mods.values():
mod.add_options(expert_grp)
for mod in demods.values():
mod.add_options(expert_grp)
(options, args) = parser.parse_args ()
tb = my_top_block(mods[options.modulation], demods[options.modulation], rx_callback, options)
pkt_size = int(options.size)
data = source_file.read(pkt_size - 2)
sequence_no = 0
tb.start()
while data != '':
payload = struct.pack('!H', sequence_no & 0xffff) + data
send_pkt(payload)
data = source_file.read(pkt_size - 2)
sequence_no += 1
send_pkt(eof=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 ok:
print payload
n_right += 1
print "right:", n_right
#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("",
"--discontinuous",
action="store_true",
default=False,
help="enable discontinuous")
parser.add_option("",
"--from-file",
default=None,
help="input file of samples to demod")
parser.add_option("",
"--freq",
type="int",
dest="rx_freq",
default=500000000,
help="set rx freq")
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():
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"
usage = "usage: %prog [options] host"
parser = OptionParser(usage=usage, 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")
my_top_block.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
blks2.ofdm_mod.add_options(parser, expert_grp)
blks2.ofdm_demod.add_options(parser, expert_grp)
(options, args) = parser.parse_args ()
address = args[0]
# build the graph
tb = my_top_block(address, 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():
global file
def rx_callback(ok, payload):
if ok:
file.write(payload)
demods = digital.modulation_utils.type_1_demods()
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("-s", "--size", type="eng_float", default=1500,
help="set packet size [default=%default]")
parser.add_option("","--samples-file", default=None,
help="Output file for modulated samples")
parser.add_option("","--to-file", default=None,
help="Output file for demodulated contents")
receive_path.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.exit(1)
if options.to_file is not None:
file = open(options.to_file, "w+")
tb = loop_top_block(demods[options.modulation], options, rx_callback)
# 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()
tb.wait()
def __init__(self,
midFreq,
fft_len,
occupied_len,
cp_len,
dinter,
callback=None):
if midFreq == None or fft_len == None or \
occupied_len == None or cp_len == None:
print 'param is not ok!'
return
if callback == None:
callback = self.rx_callback
args = ['-d', str(dinter), '-R', '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)
receive_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(callback, options)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print 'Warning: failed to enable realtime scheduling'
self.n_rcvd = 0
self.n_right = 0
print 'rx init ok!'
def add_options(normal, expert_grp, channel_grp):
mods = digital.modulation_utils.type_1_mods()
for mod in mods.values():
mod.add_options(expert_grp)
usrp_options.add_options(normal,expert_grp)
uhd_transmitter.add_options(expert_grp)
uhd_receiver.add_options(expert_grp)
transmit_path.add_options(normal,expert_grp)
receive_path.add_options(normal,expert_grp)
channel_emulator.add_options(normal,channel_grp)
expert_grp.add_option("","--use-whitener-offset", action="store_true", default=False,
help="make sequential packets use different whitening")
expert_grp.add_option("","--down-sample-rate", type="intx", default=1,
help="Select the software down-sampling rate [default=%default]")
def __init__(self, midFreq, fft_len, occupied_len, cp_len, dinter, callback = None):
if midFreq == None or fft_len == None or \
occupied_len == None or cp_len == None:
print 'param is not ok!'
return
if callback == None:
callback = self.rx_callback
args = ['-d', str(dinter), '-R', '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)
receive_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(callback, options)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print 'Warning: failed to enable realtime scheduling'
self.n_rcvd = 0
self.n_right = 0
print 'rx init ok!'
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)
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
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 ()
# 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 add_options(normal, expert):
"""
Adds usrp-specific options to the Options Parser
"""
common_options.add_options(normal, expert)
transmit_path.add_options(normal, expert)
receive_path.add_options(normal, expert)
# normal.add_option("-T", "--tx-subdev-spec", type="subdev", default=None,
# help="select USRP Tx side A or B")
expert.add_option(
"",
"--tx-freq",
type="eng_float",
default=0.0,
help="set transmit frequency to FREQ [default=%default]",
metavar="FREQ")
normal.add_option("",
"--measure",
action="store_true",
default=False,
help="enable troughput measure, usrp disabled")
# normal.add_option("", "--dyn-freq", action="store_true", default=False,
# help="enable troughput measure, usrp disabled");
expert.add_option("",
"--snr",
type="eng_float",
default=None,
help="Simulate AWGN channel")
expert.add_option("",
"--freqoff",
type="eng_float",
default=None,
help="Simulate frequency offset [default=%default]")
expert.add_option(
"",
"--samplingoffset",
type="eng_float",
default=None,
help="Simulate sampling frequency offset [default=%default]")
expert.add_option("",
"--multipath",
action="store_true",
default=False,
help="Enable multipath channel")
expert.add_option("",
"--itu-channel",
action="store_true",
default=False,
help="Enable itu channel model (ported from itpp)")
expert.add_option(
"",
"--online-work",
action="store_true",
default=False,
help=
"Force the ofdm transmitter to work during file record [default=%default]"
)
# normal.add_option("", "--from-file", type="string", default=None,
# help="Sent recorded stream with usrp")
# normal.add_option("", "--to-file", type="string", default=None,
# help="Record transmitter to disk, not being sent to usrp")
expert.add_option(
"",
"--force-tx-filter",
action="store_true",
default=False,
help="force filter use while transmitting to file or measuring")
expert.add_option(
"",
"--force-rx-filter",
action="store_true",
default=False,
help="force filter use while transmitting to file or measuring")
# expert.add_option("", "--nullsink", action="store_true",
# default=False,
# help="Throw away samples")
# normal.add_option("-e", "--interface", type="string", default="eth0",
# help="select Ethernet interface, default is eth0")
# normal.add_option("-m", "--mac-addr", type="string", default="",
# help="select USRP by MAC address, default is auto-select")
# normal.add_option("", "--usrp2", action="store_true", default=False,
# help="Use USRP2 Interface")
expert.add_option("",
"--record",
action="store_true",
default=False,
help="Record transmission stream")
expert.add_option("",
"--berm",
action="store_true",
default=False,
help="BER measurement -> set fixed noise power ")
expert.add_option("",
"--stations",
type="intx",
default=1,
help="Mobile station count")
expert.add_option(
"",
"--sinr-est",
action="store_true",
default=False,
help="Enable SINR per subcarrier estimation [default=%default]")
expert.add_option(
"",
"--est-preamble",
type="int",
default=1,
help="the number of channel estimation preambles (1 or 2)")
normal.add_option("",
"--event-rxbaseband",
action="store_true",
default=False,
help="Enable RX baseband via event channel alps")
normal.add_option("",
"--imgxfer",
action="store_true",
default=False,
help="Enable IMG Transfer mode")
def main():
#import protocol model
vfs_model = VirtualFrameScheme(PacketType, NODE_SLOT_TIME)
#node rx queue/event
global node_rx_q, node_rx_sem, thread_run, alloc_index, last_node_amount, go_on_flag,file_input,\
file_output, data, data_num
node_rx_q = Queue.Queue(maxsize = NODE_RX_MAX)
node_rx_sem = threading.Semaphore(NODE_RX_MAX) #up to the queue size
thread_run = True
go_on_flag = True
alloc_index = -1
last_node_amount = -1
data = "**heLLo**" # default data str
data_num = 0
for i in range(NODE_RX_MAX): # make all semaphore in 0 status
node_rx_sem.acquire()
def send_pkt(payload='', eof=False):
return tb.txpath.send_pkt(payload, eof)
global n_rcvd, n_right
n_rcvd = 0
n_right = 0
def rx_callback(ok, payload):
global n_rcvd, n_right
n_rcvd += 1
# Filter out incorrect pkt
if ok:
thingy = decode_common_pkt_header(tb,payload)
if not thingy:
return
(pktno,pkt_timestamp,pkt_type) = thingy
n_right += 1
now_ts = tb.sink.get_time_now().get_real_secs()
node_rx_q.put(payload)
else:
logger.warning("Packet fail. Drop pkt!")
return
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")
# parser.add_option("-M", "--megabytes", type="eng_float", default=1.0,
# help="set megabytes to transmit [default=%default]")
parser.add_option("-s", "--size", type="eng_float", default=400,
help="set packet size [default=%default]")
parser.add_option("-p", "--packno", type="eng_float", default=0,
help="set packet number [default=%default]")
parser.add_option("","--to-file", default=None,
help="Output file for modulated samples")
parser.add_option("","--bs", default=None,
help="assign if bs")
transmit_path.add_options(parser, expert_grp)
digital.ofdm_mod.add_options(parser, expert_grp)
uhd_transmitter.add_options(parser)
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 ()
# Decide is BS or Node role
IS_BS_ROLE = bool(options.bs)
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)
if options.packno is not None:
packno_delta = options.packno
logger.info("assign pktno start: %d" % packno_delta)
# build the graph
tb = my_top_block(rx_callback, options)
# USRP device aligns with PC time (NTP)
pc_now = time.time()
tb.sink.set_time_now(uhd.time_spec(pc_now))
tb.source.set_time_now(uhd.time_spec(pc_now))
now_ts = tb.sink.get_time_now().get_real_secs()
logger.info("\n{} Adjust to PC time: {}\n".format(
str(datetime.fromtimestamp(time.time())), str(datetime.fromtimestamp(now_ts))))
# get this node id
NODE_ID = tb.sink.get_usrp_mboard_serial()
# Append to required length
NODE_ID = NODE_ID.zfill(NODE_ID_LEN)
assert len(NODE_ID) == NODE_ID_LEN, "USRP NODE_ID {} len must be {}".format(NODE_ID, NODE_ID_LEN)
logger.info("\nNODE ID: {}".format(NODE_ID))
#realtime scheduling
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
logger.warn( "Warning: failed to enable realtime scheduling")
# node, open input file if assigned
if not IS_BS_ROLE and (options.from_file is not None):
try:
file_input = open(options.from_file, "r")
data = file_input.read(3)
logger.info( "Input file opened successfully")
except:
logger.error( "Error: file not exist")
# bs, open output file if assigned
if IS_BS_ROLE and (options.to_file is not None):
try:
file_output = open(options.to_file, "w+",buffering=0) #no buffering, flush rightaway
logger.info( "Output file opened successfully")
except:
logger.error( "Error: file not exist")
tb.start() # start flow graph
n = 0
pktno = 0
pkt_size = int(options.size)
def threadjob(pktno,IS_BS,NODE_ID):
global thread_run, data, go_on_flag, data_num
logger.info("Please start host now...")
boot_time = time.time()
bs_start_time = 0
nd_start_time = 0
nd_in_response = False
time_data_collecting = len(TEST_NODE_LIST)*NODE_SLOT_TIME
time_wait_for_my_slot = 0
while thread_run:
if IS_BS:
if time.time() > (bs_start_time + time_data_collecting+TRANSMIT_DELAY):
logger.info( "\n......Frame start......")
#elapsed_time = time.time() - start_time
#prepare
vfs_model.generate_seed_v_frame_rand_frame(TEST_NODE_LIST)
#send boardcast
vfs_model.send_dummy_pkt(tb) # hacking, send dummy pkt to avoid data lost
vfs_model.broadcast_vfs_pkt(tb, pkt_size, len(TEST_NODE_LIST),pktno+int(packno_delta))
pktno += 1
bs_start_time = time.time()
else:
pass
#vfs_model.send_dummy_pkt(tb)
else: #node
if (nd_in_response) and (time.time() > (nd_start_time + time_wait_for_my_slot)):
#prepare data
if go_on_flag : # get next data
logger.info( "onhand {},going to get next data".format(data))
try:
data = file_input.read(3)
if data == '':
thread_run = False
tb.txpath.send_pkt(eof=True)
tb.stop()
break
logger.info( "read current data {}".format(data))
except:
#error end
thread_run = False
tb.txpath.send_pkt(eof=True)
else: # resend last data
logger.info( "resend data {}".format(data))
vfs_model.send_dummy_pkt(tb)# hacking, send dummy pkt to avoid data lost
vfs_model.send_vfs_pkt( NODE_ID, tb, pkt_size, data, data_num, pktno)
logger.info( "\n===========================\npktno:{}\ndata numer:{}\ndata:{}\n===========================".format(pktno,data_num,data))
pktno += 1
nd_in_response = False
else:
#print "nd_in_response{}, time {} > {} ".format(nd_in_response,time.time(), (nd_start_time + time_wait_for_my_slot))
pass
#vfs_model.send_dummy_pkt(tb)
#tb.txpath.send_pkt(eof=True)
#while node_rx_sem.acquire(False):
if not node_rx_q.empty():
payload = node_rx_q.get()
if payload:
#here we need to decode the payload first
if IS_BS:
thingy = action(tb, vfs_model, payload, NODE_ID)
if thingy:
(delta, node_id, node_pktno, upload_data, data_number) = thingy
#check the data number in payload
if vfs_model.check_data_num(node_id,data_number):
logger.info("data:{} length:{}".format(upload_data,len(upload_data)))
vfs_model.set_data_num(node_id,data_number+1 & 0xffff) #keep track in vfs module
try:
#file_output.write(upload_data)
writefile(node_id,upload_data)
except:
logger.info("write file fail")
else:
logger.critical("[Seq Number mismatch]")
else:
logger.critical("[Decode Error] payload fail")
else:
logger.info( "\n... get broadcast ...")
thingy = action(tb, vfs_model, payload,NODE_ID)
if thingy:
(node_amount, seed, delta, vf_index, alloc_index, in_rand_frame, v_frame) = thingy
time_wait_for_my_slot = alloc_index * NODE_SLOT_TIME
logger.info( "I will upload at slot {}, wait for {}s".format(alloc_index,time_wait_for_my_slot))
nd_start_time = time.time()
nd_in_response = True
#vfs_model.send_vfs_pkt( NODE_ID, tb, pkt_size, "**heLLo**{}".pktno, pktno)
else:
logger.warn( "error during decode VFS_BROADCAST")
print "... thread out ..."
#node_rx_sem.release
thread = threading.Thread(target = threadjob, args = (pktno,IS_BS_ROLE,NODE_ID))
thread.daemon = True #make it a daemon thread
thread_run = True
thread.start()
time.sleep(2) # allow time for queued packets to be sent
tb.wait() # wait for it to finish
thread_run = False
while thread.isAlive():
time.sleep(1)
try:
file_input.close()
except:
pass
try:
file_output.close()
except:
pass
print "join done"
def main():
global n_rcvd, n_right, sock
UDP_IP = "localhost"
UDP_PORT = 5005
n_rcvd = 0
n_right = 0
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # UDP
def rx_callback(ok, payload):
global n_rcvd, n_right, sock
n_rcvd += 1
(pktno,) = struct.unpack('!H', payload[0:2])
data = payload[2:]
if ok:
n_right += 1
print "ok: %r \t pktno: %d \t n_rcvd: %d \t n_right: %d \t n_right: %d" % (ok, pktno, n_rcvd, n_right, len(data))
#if len(data)!=1316:
#return
#sock.sendto(data, (UDP_IP, UDP_PORT))
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"
def rx_callback_msb(ok, payload):
global n_rcvd, n_right, sock
n_rcvd += 1
(pktno,) = struct.unpack('!H', payload[0:2])
data = payload[2:]
if ok:
n_right += 1
print "MSB ok: %r \t pktno: %d \t n_rcvd: %d \t n_right: %d \t n_right: %d" % (ok, pktno, n_rcvd, n_right, len(data))
#print "\n\n\n"
#print ''.join(format(ord(x), 'b') for x in data)
#print "\n\n\n"
#if len(data)!=1316:
#return
#sock.sendto(data, (UDP_IP, UDP_PORT))
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"
def rx_callback_lsb(ok, payload):
global n_rcvd, n_right, sock
n_rcvd += 1
(pktno,) = struct.unpack('!H', payload[0:2])
data = payload[2:]
if ok:
n_right += 1
print "LSB ok: %r \t pktno: %d \t n_rcvd: %d \t n_right: %d \t n_right: %d" % (ok, pktno, n_rcvd, n_right, len(data))
#if len(data)!=1316:
#return
#sock.sendto(data, (UDP_IP, UDP_PORT))
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")
"""
parser.add_option("-a", "--args", type="string", default="",
help="Device args, [default=%default]")
parser.add_option("-A", "--antenna", type="string", default=None,
help="Select RX antenna where appropriate")
parser.add_option("-s", "--samp-rate", type="eng_float", default=None,
help="Set sample rate (bandwidth), minimum by default")
parser.add_option("-f", "--center-freq", type="eng_float", default=None,
help="Set frequency to FREQ", metavar="FREQ")
parser.add_option("-c", "--freq-corr", type="eng_float", default=None,
help="Set frequency correction (ppm)")
parser.add_option("-g", "--gain", type="eng_float", default=None,
help="Set gain in dB (default is midpoint)")
parser.add_option("-G", "--gains", type="string", default=None,
help="Set named gain in dB, name:gain,name:gain,...")
parser.add_option("-r", "--record", type="string", default="/tmp/name-f%F-s%S-t%T.cfile",
help="Filename to record to, available wildcards: %S: sample rate, %F: center frequency, %T: timestamp, Example: /tmp/name-f%F-s%S-t%T.cfile")
parser.add_option("", "--dc-offset-mode", type="int", default=None,
help="Set the RX frontend DC offset correction mode")
parser.add_option("", "--iq-balance-mode", type="int", default=None,
help="Set the RX frontend IQ imbalance correction mode")
parser.add_option("-W", "--waterfall", action="store_true", default=False,
help="Enable waterfall display")
parser.add_option("-F", "--fosphor", action="store_true", default=False,
help="Enable fosphor display")
parser.add_option("-S", "--oscilloscope", action="store_true", default=False,
help="Enable oscilloscope display")
parser.add_option("", "--avg-alpha", type="eng_float", default=1e-1,
help="Set fftsink averaging factor, default=[%default]")
parser.add_option("", "--averaging", action="store_true", default=False,
help="Enable fftsink averaging, default=[%default]")
parser.add_option("", "--ref-scale", type="eng_float", default=1.0,
help="Set dBFS=0dB input value, default=[%default]")
parser.add_option("", "--fft-size", type="int", default=1024,
help="Set number of FFT bins [default=%default]")
parser.add_option("", "--fft-rate", type="int", default=30,
help="Set FFT update rate, [default=%default]")
parser.add_option("-v", "--verbose", action="store_true", default=False,
help="Use verbose console output [default=%default]")
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 ()
# build the graph
tb = my_top_block(rx_callback,rx_callback_msb, rx_callback_lsb, 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():
global n_rcvd, n_right, pktno
n_rcvd = 0
n_right = 0
pktno = 0
def rx_callback(ok, payload):
global n_rcvd, n_right, pktno
(pktno,) = struct.unpack('!H', payload[0:2])
n_rcvd += 1
if ok:
n_right += 1
if not options.gui:
print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % (
ok, pktno, n_rcvd, n_right)
def send_pkt(payload='', eof=False):
return tb.txpath.send_pkt(payload, eof)
mods = modulation_utils.type_1_mods()
demods = modulation_utils.type_1_demods()
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
channel_grp = parser.add_option_group("Channel")
parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
default='dbpsk',
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("-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 discontinous transmission (bursts of 5 packets)")
parser.add_option("-G", "--gui", action="store_true", default=False,
help="Turn on the GUI [default=%default]")
channel_grp.add_option("", "--sample-rate", type="eng_float", default=1e5,
help="set speed of channel/simulation rate to RATE [default=%default]")
channel_grp.add_option("", "--snr", type="eng_float", default=30,
help="set the SNR of the channel in dB [default=%default]")
channel_grp.add_option("", "--frequency-offset", type="eng_float", default=0,
help="set frequency offset introduced by channel [default=%default]")
channel_grp.add_option("", "--timing-offset", type="eng_float", default=1.0,
help="set timing offset introduced by channel [default=%default]")
channel_grp.add_option("", "--seed", action="store_true", default=False,
help="use a random seed for AWGN noise [default=%default]")
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
for mod in mods.values():
mod.add_options(expert_grp)
for demod in demods.values():
demod.add_options(expert_grp)
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help()
sys.exit(1)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling"
# Create an instance of a hierarchical block
tb = my_top_block(mods[options.modulation],
demods[options.modulation],
rx_callback, options)
tb.start()
packet_sender = th_send(send_pkt, options.megabytes, options.size)
packet_sender.start()
if(options.gui):
tb.qapp.exec_()
packet_sender.stop()
else:
# Process until done; hack in to the join to stop on an interrupt
while(packet_sender.isAlive()):
try:
packet_sender.join(1)
except KeyboardInterrupt:
packet_sender.stop()
def main():
def rx_callback(ok, payload):
global pktno, pktno_receive
if ok:
#if payload[0] == 'B':
# print '\t'+"receiving beacon" + payload[0:]
if payload[0] == 'A': #ack from beacon
myPay.pause()
myPay.type = 1
myPay.restart()
#print '\t'+"receiving ack from beacon"
'''
elif payload[0] == 'a': #ack from data
myPay.pause()
for n in range(1,4):
pktno_receive = pktno_receive + payload[n]
if pktno == int(pktno_receive):
myPay.retry = 0
else:
myPay.retry = 1
myPay.restart()
print '\t'+"receiving ack from data" + payload[1:4]
elif payload[0] == 'F':
print "missino completed"
'''
#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=True,
help="enable discontinuous")
parser.add_option("-M",
"--megabytes",
type="eng_float",
default=1.0,
help="set megabytes to transmit [default=%default]")
parser.add_option("",
"--from-file",
default=None,
help="input file of samples to demod")
parser.add_option("-s",
"--size",
type="eng_float",
default=400,
help="set packet size [default=%default]")
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 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(PHY)
tb = my_top_block(rx_callback, options)
lock = threading.Lock()
myPay = payload_mgr(tb, lock, "thread", datetime.datetime.now(),
"source_file")
myPay.start()
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling"
tb.start() # start flow graph
while True:
#???bout.waitime = -1
#global rx_callback_enable, trans_status, get_ack, randombackoff, ttRB, difscount, DIFS
#trans_status = 0 #at the new frame, start with a beacon
#rx_callback_enable = 0
time.sleep(0.499)
myPay.query_database()
myPay.pause()
time.sleep(0.001)
detection = myPay.feature_detect
myPay.reset()
myPay.notification_for_primary(detection)
myPay.pause()
myPay.reset()
myPay.startSlot = datetime.datetime.now()
myPay.restart()
#??? time.sleep(0.010) #wait 10ms to detect
#??? FreCtrl.printSpace() feel that is not necessary
#print "ack status=", get_ack
#if (tb.rxpath.variable_function_probe_0 == 0): #frequency assigned by controller
# print "TV is absent... start..."
#???bout.set_waitime()
# rx_callback_enable = 1 #the right timing to receive
#time.sleep(hop_interval/1000)
#else:
# print "TV is present...wait..."
# FreCtrl.set_frequency(tb)
#???rx_callback_enable = not bool(tb.rxpath.variable_function_probe_0)
'''
nbytes = int(1e6 * options.megabytes)
n = 0
pktno = 0
pkt_size = int(options.size)
data1 = 97
print pkt_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) + chr(data1)
print "sending" + chr(data1)
send_pkt(payload)
data1 = data1 + 1
if data1 == 123:
data1 = 97
#n += len(payload)
sys.stderr.write('.')
#time.sleep(1)
#if options.discontinuous and pktno % 5 == 4:
# time.sleep(1)
pktno += 1
'''
send_pkt(eof=True)
def main():
print "ssma.py"
global n_right
n_right = 0
start_time = time.time()
print "Start Time " , start_time
parser = OptionParser (option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=['bpsk', 'qpsk'],
default='bpsk',
help="Select modulation from: bpsk, qpsk [default=%%default]")
expert_grp.add_option("-c", "--carrier-threshold", type="eng_float", default=40,
help="set carrier detect threshold (dB) [default=%default]")
expert_grp.add_option("", "--nc-filter", action="store_true", default=False)
parser.add_option("-v","--verbose", action="store_true", default=False)
# linklab, add option to indicate sender or receiver
parser.add_option("-s","--sender", action="store_true", default=False)
parser.add_option("-r","--receiver", action="store_true", default=False)
usrp_graph.add_options(parser, expert_grp)
uhd_transmitter.add_options(parser)
#uhd_receiver.add_options(parser)
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
gr_papyrus.ofdm.ofdm_mod.add_options(parser, expert_grp)
gr_papyrus.ofdm.ofdm_demod.add_options(parser, expert_grp)
(options, args) = parser.parse_args ()
options.carrier_map = SYNC_MAP
print "Added options"
print options
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
if options.rx_freq is None or options.tx_freq is None:
print ("You must specify -f FREQ or --freq FREQ\n")
parser.print_help(sys.stderr)
sys.exit(1)
# linklab, check if the current node is either a sender or a receiver
if options.sender and options.receiver:
print ("You cannot specify both sender and receiver\n")
sys.exit(1)
if (not options.sender) and (not options.receiver):
print ("You must specify either sender or receiver\n")
sys.exit(1)
#
# 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"
# instantiate the MAC
# linklab, use ssma instead of csma
mac = ss_mac(options.sender, start_time, verbose=options.verbose)
print "RX frequency", options.rx_freq
print "TX frequency", options.tx_freq
# build the graph (PHY)
tb = usrp_graph(mac.ReceivePacket, options)
print "returned from usrp_graph"
mac.set_flow_graph(tb) # give the MAC a handle for the PHY
#if fg.txpath.bitrate() != fg.rxpath.bitrate():
# print "WARNING: Transmit bitrate = %sb/sec, Receive bitrate = %sb/sec" % (
# eng_notation.num_to_str(fg.txpath.bitrate()),
# eng_notation.num_to_str(fg.rxpath.bitrate()))
print "modulation: %s" % (options.modulation,)
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
# print "bitrate: %sb/sec" % (eng_notation.num_to_str(tb.txpath.bitrate()),)
# print "samples/symbol: %3d" % (tb.txpath.samples_per_symbol(),)
# print "interp: %3d" % (tb.txpath.interp(),)
# print "decim: %3d" % (tb.rxpath.decim(),)
tb.start() # Start executing the flow graph (runs in separate threads)
mac.main_loop() # don't expect this to return...
def main():
mods = digital.modulation_utils.type_1_mods()
demods = digital.modulation_utils.type_1_demods()
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='gmsk',
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("-v","--verbose", action="store_true", default=False)
expert_grp.add_option("-c", "--carrier-threshold", type="eng_float", default=30,
help="set carrier detect threshold (dB) [default=%default]")
expert_grp.add_option("","--tun-device-filename", default="/dev/net/tun",
help="path to tun device file [default=%default]")
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
uhd_transmitter.add_options(parser)
for mod in mods.values():
mod.add_options(expert_grp)
for demod in demods.values():
demod.add_options(expert_grp)
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
# open the TUN/TAP interface
(tun_fd, tun_ifname) = open_tun_interface(options.tun_device_filename)
# 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"
# instantiate the MAC
mac = cs_mac(tun_fd, verbose=True)
# build the graph (PHY)
tb = my_top_block(mods[options.modulation],
demods[options.modulation],
mac.phy_rx_callback,
options)
mac.set_top_block(tb) # give the MAC a handle for the PHY
if tb.txpath.bitrate() != tb.rxpath.bitrate():
print "WARNING: Transmit bitrate = %sb/sec, Receive bitrate = %sb/sec" % (
eng_notation.num_to_str(tb.txpath.bitrate()),
eng_notation.num_to_str(tb.rxpath.bitrate()))
print "modulation: %s" % (options.modulation,)
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
print "bitrate: %sb/sec" % (eng_notation.num_to_str(tb.txpath.bitrate()),)
print "samples/symbol: %3d" % (tb.txpath.samples_per_symbol(),)
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
print "Carrier sense threshold:", options.carrier_threshold, "dB"
print
print "Allocated virtual ethernet interface: %s" % (tun_ifname,)
print "You must now use ifconfig to set its IP address. E.g.,"
print
print " $ sudo ifconfig %s 192.168.200.1" % (tun_ifname,)
print
print "Be sure to use a different address in the same subnet for each machine."
print
tb.start() # Start executing the flow graph (runs in separate threads)
mac.main_loop() # don't expect this to return...
tb.stop() # but if it does, tell flow graph to stop.
tb.wait() # wait for it to finish
def main():
global n_rcvd, n_right
n_rcvd = 0
n_right = 0
def send_pkt(payload='', eof=False):
return tb.txpath.send_pkt(payload, eof)
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)
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("-s", "--size", type="eng_float", default=387,
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("-r", "--sample-rate", type="eng_float", default=1e5,
help="limit sample rate to RATE in throttle (%default)")
parser.add_option("", "--snr", type="eng_float", default=30,
help="set the SNR of the channel in dB [default=%default]")
parser.add_option("", "--frequency-offset", type="eng_float", default=0,
help="set frequency offset introduced by channel [default=%default]")
parser.add_option("", "--clockrate-ratio", type="eng_float", default=1.0,
help="set clock rate ratio (sample rate difference) between two systems [default=%default]")
parser.add_option("","--discontinuous", type="int", default=0,
help="enable discontinous transmission, burst of N packets [Default is continuous]")
parser.add_option("","--channel-off", action="store_true", default=False,
help="Turns AWGN, freq offset channel off")
parser.add_option("","--multipath-on", action="store_true", default=False,
help="enable multipath")
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
digital.ofdm_mod.add_options(parser, expert_grp)
digital.ofdm_demod.add_options(parser, expert_grp)
(options, args) = parser.parse_args ()
# 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
# generate and send packets
nbytes = int(1e6 * options.megabytes)
#nbytes = int(options.size)*2
#nbytes = 0
n = 0
pktno = 0
pkt_size = int(options.size)
"""
while n < nbytes:
#r = ''.join([chr(random.randint(0,255)) for i in range(pkt_size-2)])
#pkt_contents = struct.pack('!H', pktno) + r
pkt_contents = struct.pack('!H', pktno) + (pkt_size - 2) * chr(pktno & 0xff)
send_pkt(pkt_contents)
n += pkt_size
#sys.stderr.write('.')
#if options.discontinuous and pktno % 5 == 4:
time.sleep(0.5)
pktno += 1
"""
pkt_contents = struct.pack('!H', pktno) + (pkt_size - 2) * chr(pktno & 0xff)
send_pkt(pkt_contents)
n += pkt_size
time.sleep(0.5)
pktno += 1
send_pkt(pkt_contents)
n += pkt_size
time.sleep(0.5)
pktno += 1
send_pkt(pkt_contents)
n += pkt_size
time.sleep(0.5)
pktno += 1
#sys.stderr.write('.')
#if options.discontinuous and pktno % 5 == 4:
time.sleep(1)
send_pkt(eof=True)
tb.wait() # wait for it to finish
def main():
global n_rcvd, n_right, per_wait, last_n_rcvd, freq_offset
per_wait = 0.2
freq_offset = 625000
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='dqpsk',
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
last_n_rcvd = n_rcvd
cur_freq_offset = freq_offset
tb.source.set_freq(options.rx_freq+cur_freq_offset)
while 1:
global n_rcvd, n_right, per_wait, last_n_rcvd, freq_offset
time.sleep(per_wait)
if last_n_rcvd == n_rcvd:
if cur_freq_offset > 0:
cur_freq_offset = 0-freq_offset
else:
cur_freq_offset = freq_offset
print "Switching frequency to %d\n" % (options.rx_freq+cur_freq_offset)
tb.source.set_freq(options.rx_freq+cur_freq_offset)
else:
print "Not switching frequencies since we are still receiving\n"
last_n_rcvd = n_rcvd
tb.wait() # wait for it to finish
def main():
global n_rcvd, n_right
n_rcvd = 0
n_right = 0
# linklab, add parameters for interger freq offset (int_fo), fractional freq offset (frac_fo)
# SINR estimation in time domain (time_sinr), SINR estimation in freq domain
def rx_callback(ok, payload, int_fo, frac_fo, time_sinr, freq_sinr):
global n_rcvd, n_right
n_rcvd += 1
try:
(pktno, ) = struct.unpack('!H', payload[0:2])
except:
pktno = 1
if ok:
n_right += 1
freq_offset = int_fo + frac_fo / math.pi
print "freq offset: %+.2f(subcarriers) \t SINR: %.2f(time domain), %.2f(freq domain)" % (
freq_offset, time_sinr, freq_sinr)
# linklab, calculate packet loss rate and error rate
try:
pkt_loss = (1 - n_rcvd / float(pktno)) * 100
pkt_err = (1 - n_right / float(pktno)) * 100
except:
pkt_loss = 100
pkt_err = 100
# linklab, print packet info
print "ok: %r \t pktno: %d \t n_rcvd: %d \t n_right: %d \t pkt_loss: %.2f%% \t pkt_err: %.2f%%" % (
ok, pktno, n_rcvd, n_right, pkt_loss, pkt_err)
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")
my_top_block.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
gr_papyrus.ofdm.ofdm_mod.add_options(parser, expert_grp)
gr_papyrus.ofdm.ofdm_demod.add_options(parser, expert_grp)
fusb_options.add_options(expert_grp)
(options, args) = parser.parse_args()
# 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():
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option(
"-m",
"--modulation",
type="choice",
choices=['bpsk', 'qpsk'],
default='bpsk',
help="Select modulation from: bpsk, qpsk [default=%%default]")
parser.add_option("-v", "--verbose", action="store_true", default=False)
parser.add_option("-p",
"--packets",
type="int",
default=40,
help="set number of packets to send [default=%default]")
parser.add_option(
"",
"--address",
type="string",
default='a',
help=
"set the address of the node (addresses are a single char) [default=%default]"
)
expert_grp.add_option(
"-c",
"--carrier-threshold",
type="eng_float",
default=30,
help="set carrier detect threshold (dB) [default=%default]")
usrp_graph.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
blks2.ofdm_mod.add_options(parser, expert_grp)
blks2.ofdm_demod.add_options(parser, expert_grp)
cs_mac.add_options(parser, expert_grp)
#removed 2011 May 27, MR
#fusb_options.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 or 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)
# 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"
# instantiate the MAC
mac = cs_mac(options)
# build the graph (PHY)
tb = usrp_graph(mac.phy_rx_callback, options)
mac.set_flow_graph(tb) # give the MAC a handle for the PHY
print
print "address: %s" % (options.address)
print
print "modulation: %s" % (options.modulation, )
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
print "Carrier sense threshold:", options.carrier_threshold, "dB"
# I never start the MAC main loop. We just want to recieve
# run the flow graph and wait until the user stops it.
tb.start()
while 1:
if tb.carrier_sensed():
print "Carrier Sensed"
#do stuff with the mac measurement results
print "this node sent ", mac.sent, " packets"
print "this node rcvd ", mac.rcvd, " packets"
print "this node rcvd ", mac.rcvd_ok, " packets correctly"
print "this node rcvd ", mac.rcvd_data, " data packets correctly"
def main():
parser = OptionParser (option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=['bpsk', 'qpsk'],
default='bpsk',
help="Select modulation from: bpsk, qpsk [default=%%default]")
parser.add_option("-v","--verbose", action="store_true", default=False)
expert_grp.add_option("-c", "--carrier-threshold", type="eng_float", default=30,
help="set carrier detect threshold (dB) [default=%default]")
expert_grp.add_option("","--tun-device-filename", default="/dev/net/tun",
help="path to tun device file [default=%default]")
usrp_graph.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
receive_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 ()
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
if options.rx_freq is None or 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)
# open the TUN/TAP interface
(tun_fd, tun_ifname) = open_tun_interface(options.tun_device_filename)
# 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"
# If the user hasn't set the fusb_* parameters on the command line,
# pick some values that will reduce latency.
if options.fusb_block_size == 0 and options.fusb_nblocks == 0:
if realtime: # be more aggressive
options.fusb_block_size = gr.prefs().get_long('fusb', 'rt_block_size', 1024)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'rt_nblocks', 16)
else:
options.fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
#print "fusb_block_size =", options.fusb_block_size
#print "fusb_nblocks =", options.fusb_nblocks
# instantiate the MAC
mac = cs_mac(tun_fd, verbose=True)
# build the graph (PHY)
tb = usrp_graph(mac.phy_rx_callback, options)
mac.set_flow_graph(tb) # give the MAC a handle for the PHY
#if fg.txpath.bitrate() != fg.rxpath.bitrate():
# print "WARNING: Transmit bitrate = %sb/sec, Receive bitrate = %sb/sec" % (
# eng_notation.num_to_str(fg.txpath.bitrate()),
# eng_notation.num_to_str(fg.rxpath.bitrate()))
print "modulation: %s" % (options.modulation,)
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
#print "bitrate: %sb/sec" % (eng_notation.num_to_str(fg.txpath.bitrate()),)
#print "samples/symbol: %3d" % (fg.txpath.samples_per_symbol(),)
#print "interp: %3d" % (fg.txpath.interp(),)
#print "decim: %3d" % (fg.rxpath.decim(),)
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
print "Carrier sense threshold:", options.carrier_threshold, "dB"
print
print "Allocated virtual ethernet interface: %s" % (tun_ifname,)
print "You must now use ifconfig to set its IP address. E.g.,"
print
print " $ sudo ifconfig %s 192.168.200.1" % (tun_ifname,)
print
print "Be sure to use a different address in the same subnet for each machine."
print
tb.start() # Start executing the flow graph (runs in separate threads)
mac.main_loop() # don't expect this to return...
tb.stop() # but if it does, tell flow graph to stop.
tb.wait() # wait for it to finish
def main():
global n_rcvd, n_right, timestamp_len, virtual_frame
n_rcvd = 0
n_right = 0
timestamp_len = 14 #26 # len(now)
max_pkt = 200
wrong_pktno = 0xFF00
seed_len = 20
virtual_frame = '00000000'
vf_len = 8
def get_random_seed():
seed = '{0:20}'.format(randint(1, 99999999999999999999))
# replace prefix spaces with 0, if any
return seed.replace(' ', '0')
def send_beacon_pkt(my_tb, pkt_amount):
pktno = 0 # 0 as beacon
for i in range(pkt_amount):
payload_prefix = struct.pack('!H', pktno & 0xffff)
data_size = len(payload_prefix) + timestamp_len
print "data_size {}".format(data_size)
dummy_data = (pkt_amount - data_size) * chr(pktno & 0xff)
# now = str(datetime.now())
now_timestamp_str = '{:.3f}'.format(time.time())
payload = payload_prefix + now_timestamp_str + dummy_data
my_tb.txpath.send_pkt(payload)
# sys.stderr.write('.')
print "{} send beacon signal {}...".format(str(datetime.now()), i)
time.sleep(0.001)
time.sleep(0.005)
def send_beacon_pkt2(my_tb, pkt_amount, i):
pktno = 0 # as beacon
payload_prefix = struct.pack('!H', pktno & 0xffff)
data_size = len(payload_prefix) + timestamp_len
dummy_data = (pkt_amount - data_size) * chr(pktno & 0xff)
now_timestamp_str = '{:.3f}'.format(time.time())
payload = payload_prefix + now_timestamp_str + dummy_data
my_tb.txpath.send_pkt(payload)
# sys.stderr.write('.')
print "{} send beacon signal {}...".format(str(datetime.now()), i)
def do_every(interval, send_pkt_func, my_tb, pkt_amt, iterations=1):
# For other functions to check these variables
global my_thread, my_iterations
my_iterations = iterations
if iterations < pkt_amt:
# my_thread = threading.Timer(interval, do_every,
# [interval, send_pkt_func, my_tb, pkt_amt, 0
# if iterations == 0 else iterations + 1])
my_thread = threading.Timer(interval, do_every,
[interval, send_pkt_func, my_tb, pkt_amt,
pkt_amt if iterations >= pkt_amt else iterations + 1])
#print "start thread"
my_thread.start()
# execute func
send_pkt_func(my_tb, pkt_amt, iterations)
# def send_init_pkt(my_tb, pkt_amount):
# pktno = 1
# while pktno < pkt_amount:
# if stop_init_pkt:
# print "init interrupted!!!"
# break
#
# payload_prefix = struct.pack('!H', pktno & 0xffff)
# rand_seed = get_random_seed()
# data_size = len(payload_prefix) + timestamp_len + len(rand_seed) + len(virtual_frame)
# dummy_data = (pkt_amount - data_size) * chr(pktno & 0xff)
# # now = str(datetime.now())
# now_timestamp_str = '{:.3f}'.format(time.time())
# payload = payload_prefix + now_timestamp_str + rand_seed + virtual_frame + dummy_data
# my_tb.txpath.send_pkt(payload)
# # sys.stderr.write('.')
# print "{} init pktno {}".format(str(datetime.now()), pktno)
# pktno += 1
# time.sleep(0.001)
# # print "sleep 2 seconds"
# time.sleep(0.005)
def send_init_pkt2(my_tb, pkt_amount, pktno=1):
global stop_init_pkt
if stop_init_pkt:
print "init interrupted!!!"
my_thread.cancel()
return
payload_prefix = struct.pack('!H', pktno & 0xffff)
rand_seed = get_random_seed()
data_size = len(payload_prefix) + timestamp_len + len(rand_seed) + len(virtual_frame)
dummy_data = (pkt_amount - data_size) * chr(pktno & 0xff)
# now = str(datetime.now())
now_timestamp_str = '{:.3f}'.format(time.time())
payload = payload_prefix + now_timestamp_str + rand_seed + virtual_frame + dummy_data
my_tb.txpath.send_pkt(payload)
# sys.stderr.write('.')
print "{} init pktno {}".format(str(datetime.now()), pktno)
# @time_sync(10)
# def send_ack_pkt(my_tb, temp_list):
# while temp_list:
# pktno, time_data, seed, virtual_frame = temp_list.pop(0)
# ack_pktno = pktno
# payload_prefix = struct.pack('!H', ack_pktno & 0xffff)
# data_size = len(payload_prefix) + timestamp_len + len(seed) + len(virtual_frame)
# dummy_data = (pkt_amt - data_size) * chr(ack_pktno & 0xff)
# now_timestamp_str = '{:.3f}'.format(time.time())
# payload = payload_prefix + now_timestamp_str + seed + virtual_frame + dummy_data
# my_tb.txpath.send_pkt(payload)
# #sys.stderr.write('.')
# time_data_str = str(datetime.fromtimestamp(time_data))
# print "Ack pktno {}, time {}, ack_pktno {}, seed {}, vf {}".format(pktno, time_data_str, ack_pktno, seed, virtual_frame)
# time.sleep(0.001)
# #my_tb.txpath.send_pkt(eof=True)
# time.sleep(0.005)
def send_ack_pkt2(my_tb, temp_list):
while temp_list:
pktno, time_data, seed, virtual_frame = temp_list.pop(0)
ack_pktno = pktno
payload_prefix = struct.pack('!H', ack_pktno & 0xffff)
data_size = len(payload_prefix) + timestamp_len + len(seed) + len(virtual_frame)
dummy_data = (pkt_amt - data_size) * chr(ack_pktno & 0xff)
now_timestamp_str = '{:.3f}'.format(time.time())
payload = payload_prefix + now_timestamp_str + seed + virtual_frame + dummy_data
my_tb.txpath.send_pkt(payload)
#sys.stderr.write('.')
time_data_str = str(datetime.fromtimestamp(time_data))
print "Ack pktno {}, time {}, ack_pktno {}, seed {}, vf {}".format(pktno, time_data_str, ack_pktno, seed, virtual_frame)
time.sleep(0.001)
#my_tb.txpath.send_pkt(eof=True)
time.sleep(0.005)
def rx_callback(ok, payload):
global n_rcvd, n_right, stop_init_pkt
n_rcvd += 1
(pktno,) = struct.unpack('!H', payload[0:2])
# Filter out incorrect pkt
if pktno >= wrong_pktno:
print "wrong pktno {}".format(pktno)
return
try:
pkt_timestamp_str = payload[2:2+timestamp_len]
pkt_timestamp = float(pkt_timestamp_str)
except:
print "{} is not a float.".format(pkt_timestamp_str)
return
seed = payload[2+timestamp_len:2+timestamp_len+seed_len]
virtual_frame = payload[2+timestamp_len+seed_len:2+timestamp_len+seed_len+vf_len]
now_timestamp = round(time.time(), 3)
time_delta = now_timestamp - pkt_timestamp
rx_time = str(datetime.fromtimestamp(pkt_timestamp))
if pktno == 0: # is beacon
print "received beacon. time: {}\tdelay: {}".format(rx_time, time_delta)
return
if ok:
n_right += 1
#print "received pkt. ok: %r \t pktno: %d \t time: %s \t delay: %f \t n_rcvd: %d \t n_right: %d" % (ok, pktno, rx_time, time_delta, n_rcvd, n_right)
print "received pkt. ok: {}\tpktno: {}\ttime: {}\tdelay: {}\tseed: {}\tvf: {}".format(ok, pktno, rx_time, time_delta, seed, virtual_frame)
data_list.append((pktno, pkt_timestamp, seed, virtual_frame))
if len(data_list) >= 10:
stop_init_pkt = True
def check_thread_is_done(iter_limit):
for i in range(1000):
if not my_thread.is_alive() and my_iterations >= iter_limit:
# thread done, proceed to next
break
time.sleep(0.002)
print "{} thread is done".format(str(datetime.now()))
#######
# main
#######
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")
digital.ofdm_mod.add_options(parser, expert_grp)
digital.ofdm_demod.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
uhd_transmitter.add_options(parser)
uhd_receiver.add_options(parser)
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
print "----------------------------------------------------------"
print "Input options: \n{}".format(str(options))
print "----------------------------------------------------------\n"
if options.rx_freq is None or 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)
# build the tx/rx graph
tb = TopBlock(rx_callback, options)
#init_tb()
# tb_rx = rx_top_block(rx_callback, options)
# tb_tx = tx_top_block(options)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling"
tb.start()
pkt_amt = int(options.size)
print "pkt_amt {}".format(pkt_amt)
pkt_amount = 100
# Send beacon signals. Time precision: New thread
do_every(0.005, send_beacon_pkt2, tb, pkt_amount)
# New thread checks last thread is done
check_thread_is_done(pkt_amount)
# Send initial data packets. Time precision: New thread
do_every(0.005, send_init_pkt2, tb, pkt_amount)
# New thread checks last thread is done
check_thread_is_done(pkt_amount)
# send_init_pkt(tb, MAX_PKT_AMT)
# Iteration for switching between beacon signals & data packets
# iterate = 0
# while iterate < MAX_ITERATION:
# print "iterate {}: data_list len {}".format(iterate, len(data_list))
# iterate += 1
# if data_list:
# send_ack_pkt2(tb, data_list)
# # New thread checks last thread is done
# check_thread_is_done(50)
# else:
# do_every(0.005, send_beacon_pkt2, tb, 50)
# # Another thread to check last thread is done
# check_thread_is_done(50)
# TODO: Estimate when send EOF will finish... But does it needed?
# time.sleep(5)
# print "TX send EOF pkt.............."
# tb.txpath.send_pkt(eof=True)
#tb.stop()
tb.wait()
def main():
parser = OptionParser (option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=['bpsk', 'qpsk'],
default='bpsk',
help="Select modulation from: bpsk, qpsk [default=%%default]")
parser.add_option("-v","--verbose", action="store_true", default=False)
parser.add_option("-p","--packets", type="int", default = 40,
help="set number of packets to send [default=%default]")
parser.add_option("", "--address", type="string", default = 'a',
help="set the address of the node (addresses are a single char) [default=%default]")
expert_grp.add_option("-c", "--carrier-threshold", type="eng_float", default=30,
help="set carrier detect threshold (dB) [default=%default]")
usrp_graph.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
blks2.ofdm_mod.add_options(parser, expert_grp)
blks2.ofdm_demod.add_options(parser, expert_grp)
cs_mac.add_options(parser, expert_grp)
#removed 2011 May 27, MR
#fusb_options.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 or 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)
# 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"
# instantiate the MAC
mac = cs_mac(options)
# build the graph (PHY)
tb = usrp_graph(mac.phy_rx_callback, options)
mac.set_flow_graph(tb) # give the MAC a handle for the PHY
print
print "address: %s" % (options.address)
print
print "modulation: %s" % (options.modulation,)
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
print "Carrier sense threshold:", options.carrier_threshold, "dB"
# I never start the MAC main loop. We just want to recieve
# run the flow graph and wait until the user stops it.
tb.start()
while 1:
if tb.carrier_sensed():
print "Carrier Sensed"
#do stuff with the mac measurement results
print "this node sent ", mac.sent, " packets"
print "this node rcvd ", mac.rcvd, " packets"
print "this node rcvd ", mac.rcvd_ok, " packets correctly"
print "this node rcvd ", mac.rcvd_data, " data packets correctly"
def main():
mods = digital.modulation_utils.type_1_mods()
demods = digital.modulation_utils.type_1_demods()
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='bpsk',
help="Select modulation from: %s [default=%%default]"
% (', '.join(mods.keys()),))
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("","--discontinuous", action="store_true", default=False,
help="enable discontinous transmission (bursts of 5 packets)")
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")
parser.add_option("", "--mac", default=None , help = "MAC addres")
parser.add_option("", "--version", default='6' , help = "gnuradio version, default 6 (3.6)")
parser.add_option("", "--mac_dst", default=None , help = "Destination MAC addres")
tp36.add_options(parser, expert_grp)
tp37.add_options(parser, expert_grp)
uhd_transmitter.add_options(parser)
rp36.add_options(parser, expert_grp)
rp37.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
for mod in demods.values():
mod.add_options(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')
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling"
q_tx =Queue.Queue(10)
q_rx =Queue.Queue(10)
l1=StartL1(q_rx,q_tx,options,mods[options.modulation],demods[options.modulation])
l1.start()
schL1_L2= StartSchedL1_L2(q_rx,q_tx,options.mac)
schL1_L2.start()
# POR AHORA NO USO CAPA MAC
# l2Mgmt=StartL2Mgmt(schL1_L2.mgmt_q1,schL1_L2.tx_ev_q,options.mac,"256","Red IIE")
# l2Mgmt.start()
l3= schedLayer3.Layer3(schL1_L2.tx_ev_q,schL1_L2.data_q,'/dev/net/tun',options.mac,options.mac_dst)
c = raw_input('Press #z to end, or #w to test commands :')
while c != "#z":
c = raw_input('Press #z to end, or #w to test commands :')
print "Program ends"
l3.stop()
schL1_L2.stop()
l1.stop()
#POR AHORA NO ESTOY USANDO CAPA 2
# l2.stop()
exit(0)
def main():
global n_rcvd, n_right
n_rcvd = 0
n_right = 0
node_types = {}
node_types["head"] = "head"
node_types["node"] = "node"
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()
mods = digital.modulation_utils.type_1_mods()
# 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("-s", "--size", type="eng_float", default=100,
help="set packet size [default=%default]")
parser.add_option("","--from-file", default=None,
help="input file of samples to demod")
parser.add_option("", "--node-type", type="choice", choices=node_types.keys(),
default="node",
help="Select node type from: %s [default=%%default]"
% (', '.join(node_types.keys()),))
parser.add_option("-i", "--node-index", type="intx", default=0,
help="Specify the node index in the cluster [default=%default]")
receive_path.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
uhd_sensor.add_options(parser)
uhd_transmitter.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.sx_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(node_types[options.node_type],
options.node_index,
demods[options.modulation],
mods[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
#self.source.u.stop()
#time.sleep(10)
tb.timer.start()
def main():
def send_pkt(payload='', eof=False):
return tb.txpath.send_pkt(payload, eof)
f = open("receive_file", 'w')
global n_rcvd, n_right, check_beacon_count
n_rcvd = 0
n_right = 0
def rx_callback(ok, payload):
global n_rcvd, n_right, pktno, pktno_receive, check_beacon_count
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 tb.freq / 1e6 != 600:
if payload[0] == 'B':
check_beacon_count = 0
time.sleep(0.01)
for i in range(
0, 100
): #if channel is f*****g dirty, send more time, it is a know-how
send_pkt('A')
waitime = float(payload[1:])
#print " receiving beacon: "+payload[0:]
#print "receiving beacon "
elif payload[0] == 'D':
print " pkt #: " + payload[
1:4] + " packet content: " + payload[
4:] + " frequency(MHz): " + str(tb.freq / 1e6)
check_beacon_count = 0
'''
time.sleep(0.01)
for n in range(1,4):
pktno_receive = pktno_receive + payload[n]
if pktno == int(pktno_receive):
pktno = pktno + 1
f.write(payload[4:])
for i in range(0,10):
send_pkt('a' + str(pktno_receive))
print "receiving data" + str(pktno_receive)
pktno_receive = ''
elif payload[0] == 'F':
time.sleep(0.01)
f.close()
for i in range(0,10):
send_pkt('F')
print payload[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 "\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=True,
help="enable discontinuous")
parser.add_option("-M",
"--megabytes",
type="eng_float",
default=1.0,
help="set megabytes to transmit [default=%default]")
parser.add_option("",
"--from-file",
default=None,
help="input file of samples to demod")
parser.add_option("-s",
"--size",
type="eng_float",
default=400,
help="set packet size [default=%default]")
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()
tb = my_top_block(rx_callback, options)
fre_mgr = frequency_mgr(tb, options)
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(PHY)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling"
tb.start() # start flow graph
nbytes = int(1e6 * options.megabytes)
n = 0
pktno = 0
pkt_size = int(options.size)
data1 = -1
situation = 0
while 1:
#check_beacon_count = check_beacon_count+1
#print str(tb.freq)+" MHz"
#if (check_beacon_count > 1):
# tb.change_freq();
# tb.set_tx_freq(tb.freq)
# tb.set_rx_freq(tb.freq)
# check_beacon_count =0
# print "\n"
# print " Dose not receive any beacons"
# print "\n"
fre_mgr.query_database()
#myPay.
#n += len(payload)
#sys.stderr.write('.')
#if options.discontinuous and pktno % 5 == 4:
# time.sleep(1)
time.sleep(waitime / 1000)
#time.sleep(0.1)
#check.beacon = ''
#print "the end of the interval"
#pktno += 1
send_pkt(eof=True)
tb.wait() # wait for it to finish
def main():
def ncycle(iterable, n):
for item in itertools.cycle(iterable):
for i in range(n):
yield item
hop_interval = 1000.0 # ms
maxium_resend = 100
pkt_size = 10
seq0 = ncycle([0, 0, 0, 1, 2], 1)
seq1 = ncycle([1, 1, 0, 1, 2, 2, 0], 1)
seq2 = ncycle([2, 2, 2, 1, 2, 0, 0, 1], 1)
seqs = [seq0, seq1, seq2]
def rx_callback(ok, payload):
global rx_callback_enable, cnt, numrec, returnack
if (ok and rx_callback_enable == 1):
#if (len(payload) >= 1):
if (payload[0] == 'B'):
#FreCtrl.printSpace()
#print "Receive Beacon"#, payload
synch.Synch(int(payload[1:]))
returnack = 1
myPay.getACK(synch.getRemainTime())
tb.send_pkt(myPay)
else:
if 97 <= ord(payload) <= 122:
if ord(payload) == 122:
tb.send_pkt(chr(97))
else:
tb.send_pkt((payload + 1))
#FreCtrl.printSpace()
#print "Receive Data", int(payload[1:11])
#myPay.updatePkt(payload[1:11], payload[12:]) #save the packet to the file
#tb.send_pkt('0+', payload)
#tb.send_pkt('1+', payload)
#tb.send_pkt('2+', payload)
#tb.send_pkt('3+', payload)
#tb.send_pkt('4+', payload)
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")
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=40,
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")
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 len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
# 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(rx_callback, options)
synch = Synchronize(hop_interval)
myPay = payload_mgr('./rcvd_file/rcvd_file.bmp')
debug = write_info('./rx_info.txt')
FreCtrl = frequency_mgr(seqs)
FreCtrl.check_main(
) #check whethetr the channel you post with the flag is in the seqs
FreCtrl.set_frequency(tb)
startRun = datetime.datetime.now()
tb.start() # Start5 executing the flow graph (runs in separate threads)
while True: #myPay.getSize() < 60000:
global rx_callback_enable
rx_callback_enable = 0
synch.startSlot = datetime.datetime.now()
FreCtrl.printSpace()
if (tb.rxpath.variable_function_probe_0 == 0):
print "Primary user is absent... start..."
rx_callback_enable = 1
time.sleep(synch.getInterval() / 1000)
else:
print "Primary user is present...wait..."
FreCtrl.set_frequency(tb)
#os.system('xdg-open ./rcvd_file/rcvd_file.bmp')
tb.wait() # wait for it to finish
def main():
global n_rcvd, n_right, start_time, stop_rcv
TIMEOUT = 60 # 60sec for hurdle 2
n_rcvd = 0
n_right = 0
start_time = 0
mstr_cnt = 0
stop_rcv = 0
TCP_IP='10.10.0.51'
TCP_PORT=5125
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect((TCP_IP, TCP_PORT))
except socket.error as e:
print "Error connecting to the packet sink: %s" %e.strerror
return
def rx_callback(ok, payload):
global n_rcvd, n_right, start_time, stop_rcv
(pktno,crc,sn) = struct.unpack('!HLL', payload[0:10])
n_rcvd += 1
if ok:
n_right += 1
try:
data = s.recv(4) # if a ready packet is received
s.send(payload[2:])
except socket.error as e:
print "Socket error: %s" %e.strerror
stop_rcv = 1
return
if data.__len__() == 0:
print "Connection closed"
stop_rcv = 1
return
if n_right == 1:
start_time = time.time()
if n_right == 2000:
t = time.time() - start_time
print"Mod : %5s, Rate : %8d, Time for 2000 pkts : %f sec\n" %(options.modulation, options.bitrate, t)
stop_rcv = 1;
if options.verbose:
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."
# log parameters to OML
cmd1 = "/root/OML/omlcli --out h2_benchmark --line \""
cmd1 = cmd1 + " rx-freq=" + str(options.rx_freq)
cmd1 = cmd1 + " modulation=" + str(options.modulation)
cmd1 = cmd1 + " rx-gain=" + str(options.rx_gain)
cmd1 = cmd1 + " bitrate=" + str(options.bitrate)
cmd1 = cmd1 + " sps=" + str(options.samples_per_symbol)
cmd1 = cmd1 + " hostname=" + socket.gethostname()
cmd1 = cmd1 + "\""
from subprocess import os
os.system(cmd1)
tb.start() # start flow graph
# tb.wait() # wait for it to finish
while mstr_cnt < TIMEOUT*1000:
if stop_rcv == 1:
break;
mstr_cnt = mstr_cnt + 1
time.sleep(0.001)
if stop_rcv == 0:
print "Receiver timed out, received %d packets successfully in %d sec" %(n_right, TIMEOUT)
s.close()
def main():
def fwd_callback(self, packet):
"""
Invoked by thread associated with the out queue. The resulting
packet needs to be sent out using the transmitter flowgraph.
The packet could be either a DATA pkt or an ACK pkt. In both cases,
only the pkt-hdr needs to be modulated
@param packet: the pkt to be forwarded through the transmitter chain
"""
#print "fwd_callback invoked in tunnel.py"
if packet.type() == 1:
print "<tunnel.py> tx DATA!"
#time.sleep(0.02) #IFS
#time.sleep(40)
self.tb.txpath.send_pkt(packet, 1, False)
elif packet.type() == 2:
print "<tunnel.py> tx ACK!"
self.tb.txpath.send_pkt(packet, 1, False)
else:
print "<tunnel.py> unknown pkt type:", packet.type()
def rx_callback(ok, payload, valid_timestamp, timestamp_sec,
timestamp_frac_sec):
global n_rcvd, n_right, batch_size, n_batch_correct, n_correct, n_total_batches
n_rcvd += 1
(pktno, ) = struct.unpack('!H', payload[0:2])
if ok:
n_right += 1
n_correct += 1
if 1:
# count the correct num of batches (works only for batch_size = 2) #
if (pktno + 1) % batch_size == 0:
n_total_batches += 1
# end of batch #
batch_ok = 0
if n_correct == batch_size:
n_batch_correct += 1
batch_ok = 1
print "batch ok: %r \t pktno: %d \t n_rcvd: %d \t n_right: %d \t correct_batches: %d \t total_batches: %d \t valid_ts: %d \t sec: %d \t frac_sec: %f" % (
batch_ok, pktno, n_rcvd, n_right, n_batch_correct,
n_total_batches, valid_timestamp, timestamp_sec,
timestamp_frac_sec)
n_correct = 0
def send_pkt(payload='', eof=False):
return tb.txpath.send_pkt(payload, 0, eof)
def okToTx():
return tb.rxpath.okToTx()
def disableOkToTx():
tb.rxpath.disableOkToTx()
def permitTx():
tb.txpath.permit_tx()
def isEmpty_msgq():
return tb.txpath.isEmpty_msgq()
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")
digital.ofdm_mod.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
uhd_transmitter.add_options(parser)
digital.ofdm_demod.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
(options, args) = parser.parse_args()
# build the graph
#tb = my_top_block(options)
tb = my_top_block(rx_callback, fwd_callback, 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(okToTx() == True):
if(pktno % 2 == 0):
data = (pkt_size) * chr(3 & 0xff)
else:
data = (pkt_size) * chr(4 & 0xff)
#data = (pkt_size - 2) * chr(pktno & 0xff)
#data = (pkt_size - 2) * chr(0x34)
disableOkToTx();
else:
time.sleep(0.01)
continue
#payload = struct.pack('!H', pktno & 0xffff) + data
payload = data
send_pkt(payload)
n += len(payload)
sys.stderr.write('.')
#if options.discontinuous and pktno % 5 == 4:
# time.sleep(1)
pktno += 1
time.sleep(0.65)
#time.sleep(0.1)
"""
# transmits fresh innovative packets, the mapper decides how many packets/batch to send
# mapper only sends out packets (innovative or not) when this loop permits it to send.
num_flows = 1
if (options.src == 1):
while n < nbytes:
if ((options.flow == 0) and (n > 0) and (okToTx() == False)
and (num_flows == 2)):
#if((okToTx() == False)):
time.sleep(0.02)
continue
elif ((options.flow == 1) and (okToTx() == False)
and (num_flows == 2)):
time.sleep(0.02)
continue
else:
if (isEmpty_msgq() == True):
print "Send Fresh Message -- "
num_sent = 0
while (num_sent < 2):
if (pktno % 2 == 0):
data = (pkt_size) * chr(3 & 0xff)
else:
data = (pkt_size) * chr(4 & 0xff)
payload = data
send_pkt(payload)
n += len(payload)
sys.stderr.write('.')
pktno += 1
num_sent += 1
if (num_flows == 1):
time.sleep(0.65)
permitTx()
send_pkt(eof=True)
tb.wait() # wait for it to finish
def main():
global n_rcvd, n_right, pktno
n_rcvd = 0
n_right = 0
pktno = 0
def rx_callback(ok, payload):
global n_rcvd, n_right, pktno
(pktno,) = struct.unpack('!H', payload[0:2])
n_rcvd += 1
if ok:
n_right += 1
if not options.gui:
print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % (
ok, pktno, n_rcvd, n_right)
def send_pkt(payload='', eof=False):
return tb.txpath.send_pkt(payload, eof)
mods = modulation_utils.type_1_mods()
demods = modulation_utils.type_1_demods()
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
channel_grp = parser.add_option_group("Channel")
parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
default='dbpsk',
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("-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 discontinous transmission (bursts of 5 packets)")
parser.add_option("-G", "--gui", action="store_true", default=False,
help="Turn on the GUI [default=%default]")
channel_grp.add_option("", "--sample-rate", type="eng_float", default=1e5,
help="set speed of channel/simulation rate to RATE [default=%default]")
channel_grp.add_option("", "--snr", type="eng_float", default=30,
help="set the SNR of the channel in dB [default=%default]")
channel_grp.add_option("", "--frequency-offset", type="eng_float", default=0,
help="set frequency offset introduced by channel [default=%default]")
channel_grp.add_option("", "--timing-offset", type="eng_float", default=1.0,
help="set timing offset introduced by channel [default=%default]")
channel_grp.add_option("", "--seed", action="store_true", default=False,
help="use a random seed for AWGN noise [default=%default]")
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
for mod in mods.values():
mod.add_options(expert_grp)
for demod in demods.values():
demod.add_options(expert_grp)
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help()
sys.exit(1)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling"
# Create an instance of a hierarchical block
tb = my_top_block(mods[options.modulation],
demods[options.modulation],
rx_callback, options)
tb.start()
packet_sender = th_send(send_pkt, options.megabytes, options.size)
packet_sender.start()
if(options.gui):
tb.qapp.exec_()
packet_sender.stop()
else:
# Process until done; hack in to the join to stop on an interrupt
while(packet_sender.isAlive()):
try:
packet_sender.join(1)
except KeyboardInterrupt:
packet_sender.stop()
def main():
mods = modulation_utils.type_1_mods()
demods = modulation_utils.type_1_demods()
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='gmsk',
help="Select modulation from: %s [default=%%default]"
% (', '.join(mods.keys()),))
parser.add_option("-v","--verbose", action="store_true", default=False)
parser.add_option("-n", "--nodeid", type="int", default=None,
help="specify node ID")
expert_grp.add_option("-c", "--carrier-threshold", type="eng_float", default=30,
help="set carrier detect threshold (dB) [default=%default]")
expert_grp.add_option("","--tun-device-filename", default="/dev/net/tun",
help="path to tun device file [default=%default]")
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
for mod in mods.values():
mod.add_options(expert_grp)
for demod in demods.values():
demod.add_options(expert_grp)
fusb_options.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 or 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)
# open the TUN/TAP interface
#(tun_fd, tun_ifname) = open_tun_interface(options.tun_device_filename)
# 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"
# If the user hasn't set the fusb_* parameters on the command line,
# pick some values that will reduce latency.
if options.fusb_block_size == 0 and options.fusb_nblocks == 0:
if realtime: # be more aggressive
options.fusb_block_size = gr.prefs().get_long('fusb', 'rt_block_size', 1024)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'rt_nblocks', 16)
else:
options.fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
#print "fusb_block_size =", options.fusb_block_size
#print "fusb_nblocks =", options.fusb_nblocks
# instantiate the MAC
mac = cs_mac(verbose=False)
# build the graph (PHY)
tb = my_top_block(mods[options.modulation],
demods[options.modulation],
mac.phy_rx_callback,
options)
mac.set_top_block(tb) # give the MAC a handle for the PHY
if tb.txpath.bitrate() != tb.rxpath.bitrate():
print "WARNING: Transmit bitrate = %sb/sec, Receive bitrate = %sb/sec" % (
eng_notation.num_to_str(tb.txpath.bitrate()),
eng_notation.num_to_str(tb.rxpath.bitrate()))
print "modulation: %s" % (options.modulation,)
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
print "bitrate: %sb/sec" % (eng_notation.num_to_str(tb.txpath.bitrate()),)
print "samples/symbol: %3d" % (tb.txpath.samples_per_symbol(),)
#print "interp: %3d" % (tb.txpath.interp(),)
#print "decim: %3d" % (tb.rxpath.decim(),)
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
tb.start() # Start executing the flow graph (runs in separate threads)
def main():
global n_rcvd, n_right
n_rcvd = 0
n_right = 0
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
parser.add_option(
"",
"--vr-configuration",
type="int",
default=1,
help=
"Default configuration for VR RX (matches the configuration of TX) [default=%default]"
)
expert_grp = parser.add_option_group("Expert")
expert_grp.add_option(
"-p",
"--port",
type="intx",
default=23451,
help=
"set UDP socket port number to ouput the received data [default=%default]"
)
expert_grp.add_option("-p",
"--rpc-port",
type="intx",
default=12345,
help="set UDP socket port number [default=%default]")
expert_grp.add_option("",
"--host",
default="127.0.0.1",
help="set host IP address [default=%default]")
receive_path.add_options(expert_grp, expert_grp)
uhd_receiver.add_options(expert_grp)
digital.ofdm_demod.add_options(expert_grp, expert_grp)
(options, args) = parser.parse_args()
options_vr1 = dict2obj({
'id': 0,
'tx_amplitude': 0.125,
'freq': hydra_center_frequency + vr1_initial_shift,
'bandwidth': 1e6,
'gain': 15,
'snr': options.snr,
'file': None,
'buffersize': 4072,
'modulation': 'qpsk',
'fft_length': 1024,
'occupied_tones': 800,
'cp_length': 4,
'host': options.host,
'rpc_port': options.rpc_port,
'port': options.port,
'args': options.args,
'lo_offset': options.lo_offset,
'spec': options.spec,
'antenna': options.antenna,
'clock_source': options.clock_source,
'verbose': False,
'log': False
})
options_vr2 = dict2obj({
'id': 1,
'tx_amplitude': 0.125,
'freq': hydra_center_frequency + vr2_initial_shift,
'bandwidth': 200e3,
'gain': 15,
'snr': options.snr,
'file': None,
'buffersize': 4072,
'modulation': 'bpsk',
'fft_length': 64,
'occupied_tones': 48,
'cp_length': 2,
'host': options.host,
'rpc_port': options.rpc_port,
'port': options.port + 1,
'args': options.args,
'lo_offset': options.lo_offset,
'spec': options.spec,
'antenna': options.antenna,
'clock_source': options.clock_source,
'verbose': False,
'log': False
})
vr_configuration = [options_vr1, options_vr2]
if options.vr_configuration is not None:
options = vr_configuration[options.vr_configuration - 1]
if options.freq is None:
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
parser.print_help(sys.stderr)
sys.exit(1)
cs = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
def rx_callback_vr2(ok, payload):
global n_rcvd, n_right, g_pkt_history
(pktno, ) = struct.unpack('!H', payload[0:2])
n_rcvd += 1
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)
data = payload[2:10]
cs.sendto(data, (options.host, options.port))
g_pkt_history.append(PktHistory(len(data), time.time()))
def rx_callback_vr1(ok, payload):
global n_rcvd, n_right, g_pkt_history, pkt_buffer, n_fec
MAX_RET = 2
(pktno, ) = struct.unpack('!H', payload[0:2])
n_rcvd += 1
if ok:
n_right += 1
if (pktno == 1):
if len(pkt_buffer) > 0 or ok:
if not ok and len(pkt_buffer) > 0:
n_fec += 1
data = payload[2:] if ok else pkt_buffer[0]
cs.sendto(data, (options.host, options.port))
g_pkt_history.append(PktHistory(len(data), time.time()))
pkt_buffer = []
else:
if ok:
pkt_buffer.append(payload[2:])
print "ok: %r \t pktno: %d \t n_rcvd: %d \t n_right: %d \t n_fec: %d" % (
ok, pktno, n_rcvd, n_right, n_fec)
# build the graph
tb = my_top_block(rx_callback_vr2 if options.id == 1 else rx_callback_vr1,
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
tb.xmlrpc_server.shutdown()
def main():
global pkts_rcvd
global EOF_rcvd
global num_acks
###########################
#set up options
###########################
parser = OptionParser (option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=['bpsk', 'qpsk'],
default='bpsk',
help="Select modulation from: bpsk, qpsk [default=%%default]")
parser.add_option("-v","--verbose", action="store_true", default=False)
parser.add_option("-p","--packets", type="int", default = 3000,
help="set number of packets to send [default=%default]")
parser.add_option("", "--address", type="string", default = None,
help="set the address of the node (addresses are a single char) [default=%default]")
expert_grp.add_option("-c", "--carrier-threshold", type="eng_float", default=-20,
help="set carrier detect threshold (dB) [default=%default]")
parser.add_option("", "--pkt-gen-time", type="eng_float", default=.05,
help="set the time between sending each packet (s) [default=%default]")
parser.add_option("", "--pkt-padding", type="int", default=1000,
help="pad packet with pkt-padding number of extra chars [default=%default]")
parser.add_option("","--autoselect-freq", action="store_true", default=False)
parser.add_option("", "--test-time", type="int", default=500,
help="number of seconds to run the test for [default=%default]")
usrp_graph.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
blks2.ofdm_mod.add_options(parser, expert_grp)
blks2.ofdm_demod.add_options(parser, expert_grp)
cs_mac.add_options(parser, expert_grp)
sense_path.add_options(parser, 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 or 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)
if options.address is None:
sys.stderr.write("You must specify a node address\n")
parser.print_help(sys.stderr)
sys.exit(1)
###########################
#set PHY and MAC
###########################
# 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"
pkts_sent = 0
# instantiate the MAC
mac = cs_mac(options, rx_callback)
# build the graph (PHY)
tx_failures = []
tb = usrp_graph(mac.phy_rx_callback, options)
mac.set_flow_graph(tb) # give the MAC a handle for the PHY
mac.set_error_array(tx_failures)
###########################
#manage packet generation and data gathering
###########################
print
print "address: %s" % (options.address)
print
print "modulation: %s" % (options.modulation,)
#print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
print "Carrier sense threshold:", options.carrier_threshold, "dB"
tb.start() # Start executing the flow graph (runs in separate threads)
if options.autoselect_freq:
new_freq = mac.find_best_freq()
raw_input("Press Enter to begin transmitting")
#n = 0
#while n < 50:
# os.system("clear")
# new_freq = mac.find_best_freq()
# time.sleep(.3)
# n += 1
#return
mac.start()
start_time = time.clock()
while (pkts_sent < options.packets + 3):# or not EOF_rcvd):
#if options.verbose:
# print "give a new packet to the MAC"
if pkts_sent > options.packets:
mac.new_packet('x', "EOF")
else:
mac.new_packet('x', str(pkts_sent).zfill(3) + options.pkt_padding * "k") # run the tests
pkts_sent += 1
#while not EOF_rcvd:
# time.sleep(options.pkt_gen_time)
#for some reason the timing was off, and I need a factor of two to get it
#approximately to where it should be
while time.clock() - start_time < 2*options.test_time:
pass
mac.stop()
mac.wait()
#do stuff with the measurement results
print
print time.strftime("%X")
print "this node sent: ", pkts_sent, " packets"
print "there were: ", len(tx_failures), " packets that were not successfully sent"
#print "this node received: ", num_acks, " ACK packets"
print "this node rcvd: ", len(set(pkts_rcvd)), " packets"
print "there were: ", len(pkts_rcvd) - len(set(pkts_rcvd)), " spurious packet retransmissions"
print "collisions: ", mac.collisions
if options.pkt_padding != 0:
print "the packets this node sent were of length: ", len(str(pkts_sent).zfill(3) + options.pkt_padding * "k") + 2 # + 2 for the address chars
#for item in pkts_rcvd:
# print "\t", item
#print "succesfully sent the following packets"
#for item in mac.sent_pkts:
# print "\t", item
tb.stop()
tb.wait() # wait for it to finish
def add_options(normal, expert):
"""
Adds usrp-specific options to the Options Parser
"""
add_freq_option(normal)
normal.add_option("-T",
"--tx-subdev-spec",
type="subdev",
default=None,
help="select USRP Tx side A or B")
normal.add_option("-v",
"--verbose",
action="store_true",
default=False)
expert.add_option(
"",
"--tx-freq",
type="eng_float",
default=None,
help="set transmit frequency to FREQ [default=%default]",
metavar="FREQ")
expert.add_option(
"-i",
"--interp",
type="intx",
default=256,
help="set fpga interpolation rate to INTERP [default=%default]")
normal.add_option("-R",
"--rx-subdev-spec",
type="subdev",
default=None,
help="select USRP Rx side A or B")
normal.add_option(
"",
"--rx-gain",
type="eng_float",
default=None,
metavar="GAIN",
help=
"set receiver gain in dB [default=midpoint]. See also --show-rx-gain-range"
)
normal.add_option(
"",
"--show-rx-gain-range",
action="store_true",
default=False,
help="print min and max Rx gain available on selected daughterboard"
)
normal.add_option("-v",
"--verbose",
action="store_true",
default=False)
expert.add_option("",
"--rx-freq",
type="eng_float",
default=None,
help="set Rx frequency to FREQ [default=%default]",
metavar="FREQ")
expert.add_option(
"-d",
"--decim",
type="intx",
default=128,
help="set fpga decimation rate to DECIM [default=%default]")
expert.add_option(
"",
"--snr",
type="eng_float",
default=30,
help="set the SNR of the channel in dB [default=%default]")
#other necessary options
transmit_path.add_options(normal, expert)
receive_path.add_options(normal, expert)
blks2.ofdm_mod.add_options(normal, expert)
blks2.ofdm_demod.add_options(normal, expert)
fusb_options.add_options(expert)
def main():
global n_right
n_right = 0
start_time = time.time()
parser = OptionParser (option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=['bpsk', 'qpsk'],
default='bpsk',
help="Select modulation from: bpsk, qpsk [default=%%default]")
expert_grp.add_option("-c", "--carrier-threshold", type="eng_float", default=40,
help="set carrier detect threshold (dB) [default=%default]")
parser.add_option("-v","--verbose", action="store_true", default=False)
# linklab, add option to indicate sender or receiver
parser.add_option("-s","--sender", action="store_true", default=False)
parser.add_option("-r","--receiver", action="store_true", default=False)
usrp_graph.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
receive_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 ()
options.carrier_map = SYNC_MAP
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
if options.rx_freq is None or 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)
# linklab, check if the current node is either a sender or a receiver
if options.sender and options.receiver:
sys.stderr.write("You cannot specify both sender and receiver\n")
sys.exit(1)
if (not options.sender) and (not options.receiver):
sys.stderr.write("You must specify either sender or receiver\n")
sys.exit(1)
#
# 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"
# If the user hasn't set the fusb_* parameters on the command line,
# pick some values that will reduce latency.
if options.fusb_block_size == 0 and options.fusb_nblocks == 0:
if realtime: # be more aggressive
options.fusb_block_size = gr.prefs().get_long('fusb', 'rt_block_size', 1024)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'rt_nblocks', 16)
else:
options.fusb_block_size = gr.prefs().get_long('fusb', 'block_size', 4096)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
#print "fusb_block_size =", options.fusb_block_size
#print "fusb_nblocks =", options.fusb_nblocks
# instantiate the MAC
# linklab, use ssma instead of csma
mac = ss_mac(options.sender, start_time, verbose=True)
# update freq_offset
options.rx_freq += get_freq_offset()
options.tx_freq += get_freq_offset()
print "RX frequency", options.rx_freq
print "TX frequency", options.tx_freq
# build the graph (PHY)
tb = usrp_graph(mac.ReceivePacket, options)
mac.set_flow_graph(tb) # give the MAC a handle for the PHY
#if fg.txpath.bitrate() != fg.rxpath.bitrate():
# print "WARNING: Transmit bitrate = %sb/sec, Receive bitrate = %sb/sec" % (
# eng_notation.num_to_str(fg.txpath.bitrate()),
# eng_notation.num_to_str(fg.rxpath.bitrate()))
print "modulation: %s" % (options.modulation,)
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
# print "bitrate: %sb/sec" % (eng_notation.num_to_str(tb.txpath.bitrate()),)
# print "samples/symbol: %3d" % (tb.txpath.samples_per_symbol(),)
# print "interp: %3d" % (tb.txpath.interp(),)
# print "decim: %3d" % (tb.rxpath.decim(),)
tb.start() # Start executing the flow graph (runs in separate threads)
mac.main_loop() # don't expect this to return...
while 1:
pass
def main():
parser = OptionParser (option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=['bpsk', 'qpsk'],
default='bpsk',
help="Select modulation from: bpsk, qpsk [default=%%default]")
parser.add_option("-v","--verbose", action="store_true", default=False)
expert_grp.add_option("-c", "--carrier-threshold", type="eng_float", default=30,
help="set carrier detect threshold (dB) [default=%default]")
expert_grp.add_option("","--tun-device-filename", default="/dev/net/tun",
help="path to tun device file [default=%default]")
digital.ofdm_mod.add_options(parser, expert_grp)
digital.ofdm_demod.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
uhd_transmitter.add_options(parser)
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
if options.rx_freq is None or 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)
# open the TUN/TAP interface
(tun_fd, tun_ifname) = open_tun_interface(options.tun_device_filename)
# 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"
# instantiate the MAC
mac = cs_mac(tun_fd, verbose=True)
# build the graph (PHY)
tb = my_top_block(mac.phy_rx_callback, options)
mac.set_flow_graph(tb) # give the MAC a handle for the PHY
print "modulation: %s" % (options.modulation,)
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
print "Carrier sense threshold:", options.carrier_threshold, "dB"
print
print "Allocated virtual ethernet interface: %s" % (tun_ifname,)
print "You must now use ifconfig to set its IP address. E.g.,"
print
print " $ sudo ifconfig %s 192.168.200.1" % (tun_ifname,)
print
print "Be sure to use a different address in the same subnet for each machine."
print
tb.start() # Start executing the flow graph (runs in separate threads)
mac.main_loop() # don't expect this to return...
tb.stop() # but if it does, tell flow graph to stop.
tb.wait() # wait for it to finish
def main():
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option(
"-m",
"--modulation",
type="choice",
choices=['bpsk', 'qpsk'],
default='bpsk',
help="Select modulation from: bpsk, qpsk [default=%%default]")
parser.add_option("-v", "--verbose", action="store_true", default=False)
expert_grp.add_option(
"-c",
"--carrier-threshold",
type="eng_float",
default=30,
help="set carrier detect threshold (dB) [default=%default]")
expert_grp.add_option("",
"--tun-device-filename",
default="/dev/net/tun",
help="path to tun device file [default=%default]")
digital.ofdm_mod.add_options(parser, expert_grp)
digital.ofdm_demod.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
uhd_transmitter.add_options(parser)
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
'''
if options.rx_freq is None or 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)
'''
# open the TUN/TAP interface
(tun_fd, tun_ifname) = open_tun_interface(options.tun_device_filename)
tun_config(tun_ifname)
# 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"
# instantiate the MAC
mac = cs_mac(tun_fd, verbose=True)
# build the graph (PHY)
options.bandwidth = BAND_USRP
options.tx_freq = TXFREQ_USRP
options.rx_freq = RXFREQ_USRP
options.args = ADDR_USRP
tb = my_top_block(mac.phy_rx_callback, options)
mac.set_flow_graph(tb) # give the MAC a handle for the PHY
print "modulation: %s" % (options.modulation, )
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
print "Carrier sense threshold:", options.carrier_threshold, "dB"
print
print "Allocated virtual ethernet interface: %s" % (tun_ifname, )
print "You must now use ifconfig to set its IP address. E.g.,"
print
print " $ sudo ifconfig %s 192.168.200.1" % (tun_ifname, )
print
print "Be sure to use a different address in the same subnet for each machine."
print
tb.start() # Start executing the flow graph (runs in separate threads)
threading.Thread(target=mac.arq_fsm).start()
# mac.main_loop() # don't expect this to return...
# tb.stop() # but if it does, tell flow graph to stop.
tb.wait() # wait for it to finish
def main():
mods = digital.modulation_utils.type_1_mods()
demods = digital.modulation_utils.type_1_demods()
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='gmsk',
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("-v","--verbose", action="store_true", default=False)
parser.add_option("-p", "--PLR", type="intx", default=3,
help="set packet loss rate [default=%default]")
parser.add_option("-T", "--packLen", type="intx", default=200,
help="set source symbol numbers [default=%default]")
expert_grp.add_option("-c", "--carrier-threshold", type="eng_float", default=30,
help="set carrier detect threshold (dB) [default=%default]")
expert_grp.add_option("","--tun-device-filename", default="/dev/net/tun",
help="path to tun device file [default=%default]")
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
uhd_transmitter.add_options(parser)
for mod in mods.values():
mod.add_options(expert_grp)
for demod in demods.values():
demod.add_options(expert_grp)
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
# open the TUN/TAP interface
#(tun_fd, tun_ifname) = open_tun_interface(options.tun_device_filename)
if options.rx_freq is None or 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)
# 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"
# instantiate the MAC
#mac = cs_mac(tun_fd, verbose=True)
mac = cs_mac(verbose=True)
# build the graph (PHY)
tb = my_top_block(mods[options.modulation],
demods[options.modulation],
mac.phy_rx_callback,
options)
mac.set_top_block(tb) # give the MAC a handle for the PHY
if tb.txpath.bitrate() != tb.rxpath.bitrate():
print "WARNING: Transmit bitrate = %sb/sec, Receive bitrate = %sb/sec" % (
eng_notation.num_to_str(tb.txpath.bitrate()),
eng_notation.num_to_str(tb.rxpath.bitrate()))
print "modulation: %s" % (options.modulation,)
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
print "bitrate: %sb/sec" % (eng_notation.num_to_str(tb.txpath.bitrate()),)
print "samples/symbol: %3d" % (tb.txpath.samples_per_symbol(),)
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
print "Carrier sense threshold:", options.carrier_threshold, "dB"
source_file = open('./foreman_cif.264', 'r')
#print 'zhifeng: from file'
#print 'source_file = ', source_file
file_data = source_file.read()
file_length = len(file_data)
#print "file length is", file_length
#print file_data
#raw_input('zhifeng on 070928: press any key to continue')
source_file.close()
tb.start() # Start executing the flow graph (runs in separate threads)
#K = 100
print "PLR: %s" % (options.PLR,)
mac.main_loop(file_data, options.packLen, options.PLR) # don't expect this to return...
tb.stop() # but if it does, tell flow graph to stop.
tb.wait() # wait for it to finish
def main():
parser = OptionParser(conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
ofdm_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_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('~/omnilog/benchmark_ofdm.dot')
filetx = os.path.expanduser('benchmark_ofdm.dot')
dot_file = open(filetx, 'w')
dot_file.write(string_benchmark)
dot_file.close()
runtime.run()
try:
tx.txpath._control._id_source.ready()
except:
pass
except KeyboardInterrupt:
runtime.stop()
# somewhat messy hack
# try:
# rx.rxs_msgq.flush()
# rx.rxs_msgq.insert_tail(gr.message(1))
# except:
# print "Could not flush msgq"
# pass
runtime.wait()
if options.measure:
print "min", tx.m.get_min()
print "max", tx.m.get_max()
print "avg", tx.m.get_avg()
def main():
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option(
"-m",
"--modulation",
type="choice",
choices=['bpsk', 'qpsk'],
default='bpsk',
help="Select modulation from: bpsk, qpsk [default=%%default]")
parser.add_option("-v", "--verbose", action="store_true", default=False)
expert_grp.add_option(
"-c",
"--carrier-threshold",
type="eng_float",
default=30,
help="set carrier detect threshold (dB) [default=%default]")
expert_grp.add_option("",
"--tun-device-filename",
default="/dev/net/tun",
help="path to tun device file [default=%default]")
usrp_graph.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
receive_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()
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
if options.rx_freq is None or 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)
# open the TUN/TAP interface
(tun_fd, tun_ifname) = open_tun_interface(options.tun_device_filename)
# 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"
# If the user hasn't set the fusb_* parameters on the command line,
# pick some values that will reduce latency.
if options.fusb_block_size == 0 and options.fusb_nblocks == 0:
if realtime: # be more aggressive
options.fusb_block_size = gr.prefs().get_long(
'fusb', 'rt_block_size', 1024)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'rt_nblocks',
16)
else:
options.fusb_block_size = gr.prefs().get_long(
'fusb', 'block_size', 4096)
options.fusb_nblocks = gr.prefs().get_long('fusb', 'nblocks', 16)
#print "fusb_block_size =", options.fusb_block_size
#print "fusb_nblocks =", options.fusb_nblocks
# instantiate the MAC
mac = cs_mac(tun_fd, verbose=True)
# build the graph (PHY)
tb = usrp_graph(mac.phy_rx_callback, options)
mac.set_flow_graph(tb) # give the MAC a handle for the PHY
#if fg.txpath.bitrate() != fg.rxpath.bitrate():
# print "WARNING: Transmit bitrate = %sb/sec, Receive bitrate = %sb/sec" % (
# eng_notation.num_to_str(fg.txpath.bitrate()),
# eng_notation.num_to_str(fg.rxpath.bitrate()))
print "modulation: %s" % (options.modulation, )
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
#print "bitrate: %sb/sec" % (eng_notation.num_to_str(fg.txpath.bitrate()),)
#print "samples/symbol: %3d" % (fg.txpath.samples_per_symbol(),)
#print "interp: %3d" % (fg.txpath.interp(),)
#print "decim: %3d" % (fg.rxpath.decim(),)
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
print "Carrier sense threshold:", options.carrier_threshold, "dB"
print
print "Allocated virtual ethernet interface: %s" % (tun_ifname, )
print "You must now use ifconfig to set its IP address. E.g.,"
print
print " $ sudo ifconfig %s 192.168.200.1" % (tun_ifname, )
print
print "Be sure to use a different address in the same subnet for each machine."
print
tb.start() # Start executing the flow graph (runs in separate threads)
mac.main_loop() # don't expect this to return...
tb.stop() # but if it does, tell flow graph to stop.
tb.wait() # wait for it to finish
def main():
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option(
"-m",
"--modulation",
type="choice",
choices=['bpsk', 'qpsk'],
default='bpsk',
help="Select modulation from: bpsk, qpsk [default=%%default]")
parser.add_option("-v", "--verbose", action="store_true", default=False)
expert_grp.add_option(
"-c",
"--carrier-threshold",
type="eng_float",
default=30,
help="set carrier detect threshold (dB) [default=%default]")
expert_grp.add_option(
"",
"--snr",
type="eng_float",
default=30,
help="set the SNR of the channel in dB [default=%default]")
digital.ofdm_mod.add_options(parser, expert_grp)
digital.ofdm_demod.add_options(parser, expert_grp)
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
uhd_transmitter.add_options(parser)
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
if options.rx_freq is None or 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)
# 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"
# instantiate the MAC
mac = cs_mac(verbose=True)
# build the graph (PHY)
tb = my_top_block(mac.phy_rx_callback, mac.fwd_callback, options)
mac.set_flow_graph(tb) # give the MAC a handle for the PHY
print "modulation: %s" % (options.modulation, )
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
print "Carrier sense threshold:", options.carrier_threshold, "dB"
tb.start() # Start executing the flow graph (runs in separate threads)
mac.main_loop() # don't expect this to return...
tb.stop() # but if it does, tell flow graph to stop.
tb.wait() # wait for it to finish
def main(top_block_cls=ofdm_multichannel_receiver, options=None):
global n_rcvd, n_right, printout
n_rcvd = 0
n_right = 0
printout = False
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
if printout:
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)
if printout:
print printable
print "\n"
################################################
# SETUP options
# {'from_file': None, 'verbose': False, 'antenna': None, 'discontinuous': False,
# 'args': 'addr=192.168.20.2', 'tx_freq': 900000000.0, 'fft_length': 512,
# 'modulation': 'bpsk', 'bandwidth': 500000.0, 'snr': 30.0, 'log': False,
# 'clock_source': None, 'lo_offset': 0, 'occupied_tones': 200,
# 'cp_length': 128, 'freq': None, 'rx_freq': 900000000.0, 'spec': None, 'rx_gain': None}
# options['from_file'] = None
# options.verbose = False
# options.antenna = None
# options.discontinuous = False
# options.args = 'addr=192.168.20.2'
# options.tx_freq = 900000000
# options.fft_length = 512
# options.modulation = 'bpsk'
# options.bandwidth = 500000
# options.snr = 30
# options.log = False
# options.clock_source = None
# options.lo_offset = 0
# options.occupied_tones = 200
# options.cp_length = 128
# options.freq = None
# options.rx_freq = 900000000
# options.spec = None
# options.rx_gain = None
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:
options.rx_freq = 900000000
################################################
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(rx_callback, options)
tb.start()
tb.show()
def quitting():
tb.stop()
tb.wait()
qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting)
qapp.exec_()
def main():
gnlogger.logconf() # initializes the logging facility
module_logger.info('start this module')
mods = digital.modulation_utils.type_1_mods()
demods = digital.modulation_utils.type_1_demods()
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='bpsk',
help="Select modulation from: %s [default=%%default]"
% (', '.join(mods.keys()),))
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("","--discontinuous", action="store_true", default=False,
help="enable discontinous transmission (bursts of 5 packets)")
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")
parser.add_option("", "--mac", default=None , help = "MAC addres")
parser.add_option("", "--version", default='6' , help = "gnuradio version, default 6 (3.6)")
parser.add_option("", "--mac_dst", default=None , help = "Destination MAC addres")
parser.add_option("","--master", action="store_true",default=False, dest= 'master',
help="Master in TDMA Network")
parser.add_option("","--slave", action="store_false",default=False, dest= 'master',
help="Slave in TDMA Network")
tp36.add_options(parser, expert_grp)
tp37.add_options(parser, expert_grp)
uhd_transmitter.add_options(parser)
rp36.add_options(parser, expert_grp)
rp37.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
for mod in demods.values():
mod.add_options(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')
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling"
q_L1_tx =Queue.Queue(10)
q_L1_rx =Queue.Queue(10)
l1=StartL1(q_L1_rx,q_L1_tx,options,mods[options.modulation],demods[options.modulation])
l1.start()
schL1_L2= StartSchedL1_L2(q_L1_rx,q_L1_tx)
schL1_L2.start()
# POR AHORA NO USO CAPA MAC
# l2Mgmt=StartL2Mgmt(schL1_L2.mgmt_q1,schL1_L2.tx_ev_q,options.mac,"256","Red IIE")
# l2Mgmt.start()
L2_ctrl_rx_q =Queue.Queue(10)
L2_data_rx_q =Queue.Queue(5)
L2_event_tx_q = Queue.Queue(10)
l3= schedLayer3.Layer3(L2_data_rx_q,L2_event_tx_q,'/dev/net/tun',options.mac,options.mac_dst)
"OJO POR AHORA LE ESTOY PASANDO A LA MAC TDMA LA COLA DE MGMT Y NO LA CTRL PORQUE EL CANAL DE CONTRL ES UN BEACON____!!!!!!!"
if options.master:
net_conf = NetworkConfiguration.NetworkConfiguration(options.mac,'my network',256,1)
net_conf.slots = 3
" The first slot is the control slot, the others are for data"
net_conf.control_time = 0.9
" Each slot has 1 second"
net_conf.list_nodes.append(options.mac)
net_conf.list_nodes.append(options.mac_dst)
mac_tdma = Mac.MacTdma(net_conf,schL1_L2.mgmt_q,schL1_L2.data_q,L2_ctrl_rx_q,L2_data_rx_q,schL1_L2.tx_ev_q,L2_event_tx_q,options.master)
else:
net_conf = NetworkConfiguration.NetworkConfiguration(options.mac,'my network',256,1)
mac_tdma = Mac.MacTdma(net_conf,schL1_L2.mgmt_q,schL1_L2.data_q,L2_ctrl_rx_q,L2_data_rx_q,schL1_L2.tx_ev_q,L2_event_tx_q,options.master)
c = raw_input('Press #z to end, or #w to test commands :')
while c != "#z":
c = raw_input('Press #z to end, or #w to test commands :')
print "Program ends"
l3.stop()
schL1_L2.stop()
l1.stop()
mac_tdma.stop()
#POR AHORA NO ESTOY USANDO CAPA 2
# l2.stop()
exit(0)
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])
data = payload[2:]
n_rcvd += 1
if ok:
n_right += 1
if options.server:
sock.sendall(data)
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")
parser.add_option("",
"--server",
action="store_true",
default=False,
help="To take data from the server")
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)
# connect to server
if options.server:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = ('10.0.0.200', 50001)
print >> sys.stderr, 'connecting to %s port %s' % server_address
sock.connect(server_address)
# 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
if options.server:
sock.close()
def main():
global n_rcvd, n_right, start_time, start, once
once = 1
n_rcvd = 0
n_right = 0
def rx_callback(ok, payload):
global n_rcvd, n_right
try:
(pktno, ) = struct.unpack('!H', payload[0:2])
data = payload[2:]
n_rcvd += 1
if ok:
n_right += 1
if options.server:
sock.sendall(data)
current = time.time() - start
except:
print "except"
#print "current time = %f ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % (current, ok, pktno, n_rcvd, n_right)
omlDb.inject("packets", ("received", n_rcvd))
omlDb.inject("packets", ("correct", 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',
help="Select modulation from: %s [default=%%default]" %
(', '.join(demods.keys()), ))
parser.add_option("",
"--from-file",
default=None,
help="input file of samples to demod")
parser.add_option("-E",
"--exp-id",
type="string",
default="test",
help="specify the experiment ID")
parser.add_option("-N",
"--node-id",
type="string",
default="rx",
help="specify the experiment ID")
parser.add_option("",
"--server",
action="store_true",
default=False,
help="To take data from the server")
parser.add_option("",
"--port",
type="int",
default=None,
help="specify the server port")
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()
omlDb = OMLBase("gnuradiorx", options.exp_id, options.node_id,
"tcp:nitlab3.inf.uth.gr:3003")
omlDb.addmp("packets", "type:string value:long")
omlDb.start()
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)
# connect to server
if options.server:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# server_address = ('10.0.1.200', 50001)
server_address = ('10.0.1.200', options.port)
print >> sys.stderr, 'connecting to %s port %s' % server_address
sock.connect(server_address)
# 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
start = time.time()
while 1:
current = time.time() - start
if current >= 5:
symbol_rate = options.bitrate / demods[options.modulation](
**args).bits_per_symbol()
tb.source.set_sample_rate(symbol_rate, options.samples_per_symbol)
options.rx_freq += 0.75e6
tb.source.set_freq(options.rx_freq, options.lo_offset)
break
#print "FROM OPTIONS.........", tb.source._freq
tb.wait() # wait for it to finish
if options.server:
sock.close()
def main():
mods = digital.modulation_utils.type_1_mods()
demods = digital.modulation_utils.type_1_demods()
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='gmsk',
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("-v", "--verbose", action="store_true", default=False)
expert_grp.add_option(
"-c",
"--carrier-threshold",
type="eng_float",
default=30,
help="set carrier detect threshold (dB) [default=%default]")
expert_grp.add_option("",
"--tun-device-filename",
default="/dev/net/tun",
help="path to tun device file [default=%default]")
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
uhd_transmitter.add_options(parser)
for mod in mods.values():
mod.add_options(expert_grp)
for demod in demods.values():
demod.add_options(expert_grp)
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
# open the TUN/TAP interface
(tun_fd, tun_ifname) = open_tun_interface(options.tun_device_filename)
# 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"
# instantiate the MAC
mac = cs_mac(tun_fd, verbose=True)
# build the graph (PHY)
tb = my_top_block(mods[options.modulation], demods[options.modulation],
mac.phy_rx_callback, options)
mac.set_top_block(tb) # give the MAC a handle for the PHY
if tb.txpath.bitrate() != tb.rxpath.bitrate():
print "WARNING: Transmit bitrate = %sb/sec, Receive bitrate = %sb/sec" % (
eng_notation.num_to_str(tb.txpath.bitrate()),
eng_notation.num_to_str(tb.rxpath.bitrate()))
print "modulation: %s" % (options.modulation, )
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
print "bitrate: %sb/sec" % (eng_notation.num_to_str(
tb.txpath.bitrate()), )
print "samples/symbol: %3d" % (tb.txpath.samples_per_symbol(), )
tb.rxpath.set_carrier_threshold(options.carrier_threshold)
print "Carrier sense threshold:", options.carrier_threshold, "dB"
print
print "Allocated virtual ethernet interface: %s" % (tun_ifname, )
print "You must now use ifconfig to set its IP address. E.g.,"
print
print " $ sudo ifconfig %s 192.168.200.1" % (tun_ifname, )
print
print "Be sure to use a different address in the same subnet for each machine."
print
tb.start() # Start executing the flow graph (runs in separate threads)
mac.main_loop() # don't expect this to return...
tb.stop() # but if it does, tell flow graph to stop.
tb.wait() # wait for it to finish
def main():
global n_rcvd, n_right, pktno
n_rcvd = 0
n_right = 0
pktno = 1
def rx_callback(ok, payload):
global n_rcvd, n_right, pktno
(pktno,) = struct.unpack('!H', payload[0:2])
n_rcvd += 1
if ok:
n_right += 1
if not options.gui:
print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % (
ok, pktno, n_rcvd, n_right)
demods = modulation_utils2.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='dbpsk2',
help="Select modulation from: %s [default=%%default]"
% (', '.join(demods.keys()),))
my_top_block.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
usrp_options.add_rx_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.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
if(options.gui):
tb.qapp.exec_()
else:
tb.wait() # wait for it to finish
def main():
print "ssma.py"
global n_right
n_right = 0
start_time = time.time()
print "Start Time ", start_time
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option(
"-m",
"--modulation",
type="choice",
choices=['bpsk', 'qpsk'],
default='bpsk',
help="Select modulation from: bpsk, qpsk [default=%%default]")
expert_grp.add_option(
"-c",
"--carrier-threshold",
type="eng_float",
default=40,
help="set carrier detect threshold (dB) [default=%default]")
expert_grp.add_option("",
"--nc-filter",
action="store_true",
default=False)
parser.add_option("-v", "--verbose", action="store_true", default=False)
# linklab, add option to indicate sender or receiver
parser.add_option("-s", "--sender", action="store_true", default=False)
parser.add_option("-r", "--receiver", action="store_true", default=False)
usrp_graph.add_options(parser, expert_grp)
uhd_transmitter.add_options(parser)
#uhd_receiver.add_options(parser)
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
gr_papyrus.ofdm.ofdm_mod.add_options(parser, expert_grp)
gr_papyrus.ofdm.ofdm_demod.add_options(parser, expert_grp)
(options, args) = parser.parse_args()
options.carrier_map = SYNC_MAP
print "Added options"
print options
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
if options.rx_freq is None or options.tx_freq is None:
print("You must specify -f FREQ or --freq FREQ\n")
parser.print_help(sys.stderr)
sys.exit(1)
# linklab, check if the current node is either a sender or a receiver
if options.sender and options.receiver:
print("You cannot specify both sender and receiver\n")
sys.exit(1)
if (not options.sender) and (not options.receiver):
print("You must specify either sender or receiver\n")
sys.exit(1)
#
# 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"
# instantiate the MAC
# linklab, use ssma instead of csma
mac = ss_mac(options.sender, start_time, verbose=options.verbose)
print "RX frequency", options.rx_freq
print "TX frequency", options.tx_freq
# build the graph (PHY)
tb = usrp_graph(mac.ReceivePacket, options)
print "returned from usrp_graph"
mac.set_flow_graph(tb) # give the MAC a handle for the PHY
#if fg.txpath.bitrate() != fg.rxpath.bitrate():
# print "WARNING: Transmit bitrate = %sb/sec, Receive bitrate = %sb/sec" % (
# eng_notation.num_to_str(fg.txpath.bitrate()),
# eng_notation.num_to_str(fg.rxpath.bitrate()))
print "modulation: %s" % (options.modulation, )
print "freq: %s" % (eng_notation.num_to_str(options.tx_freq))
# print "bitrate: %sb/sec" % (eng_notation.num_to_str(tb.txpath.bitrate()),)
# print "samples/symbol: %3d" % (tb.txpath.samples_per_symbol(),)
# print "interp: %3d" % (tb.txpath.interp(),)
# print "decim: %3d" % (tb.rxpath.decim(),)
tb.start() # Start executing the flow graph (runs in separate threads)
mac.main_loop() # don't expect this to return...
