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 = 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")
usrp_receive_path.add_options(parser, expert_grp)
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.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
fg.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 = 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")
receive_path.add_options(parser, expert_grp)
for mod in demods.values():
mod.add_options(expert_grp)
fusb_options.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.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)
# print "payload ", payload
demods = modulation_utils.type_1_demods()
# Create Options Parser:
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option(
"-m",
"--modulation",
type="choice",
choices=demods.keys(),
default="gmsk", #'dbpsk', need to add SNR stuff
help="Select modulation from: %s [default=%%default]" % (", ".join(demods.keys()),),
)
usrp_receive_path2.add_options(parser, expert_grp)
for mod in demods.values():
mod.add_options(expert_grp)
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
if options.rx_freq is None:
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
parser.print_help(sys.stderr)
sys.exit(1)
# build the graph
tb = my_top_block(demods[options.modulation], rx_callback, options)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: Failed to enable realtime scheduling."
tb.start() # start flow graph
tb.wait() # wait for it to finish
def main():
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 = 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()), ))
usrp_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.stderr)
sys.exit(1)
if options.rx_freq is None:
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
parser.print_help(sys.stderr)
sys.exit(1)
# build the graph
tb = my_top_block(demods[options.modulation], rx_callback, options)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: Failed to enable realtime scheduling."
tb.start() # start flow graph
tb.wait() # wait for it to finish
def __init__(self, callback):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option,
conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("",
"--discontinuous",
action="store_true",
default=False,
help="enable discontinuous")
transceiver.add_options(parser, expert_grp)
args = ['-f', '2.4G', '-u', '1', '-i', '64', '-d', '32']
(options, args) = parser.parse_args(args)
#init receive
self._rx_freq = options.rx_freq
self._rx_gain = options.rx_gain
self._rx_subdev_spec = options.rx_subdev_spec
self._decim = options.decim
#init transmit
self._tx_freq = options.tx_freq
self._tx_subdev_spec = options.tx_subdev_spec
self._interp = options.interp
#check receive
if self._rx_freq is None:
sys.stderr.write(
"-f FREQ or --freq FREQ or --rx-freq FREQ must be specified\n")
raise SystemExit
#check transmit
if self._tx_freq is None:
sys.stderr.write(
"-f FREQ or --freq FREQ or --rx-freq FREQ must be specified\n")
raise SystemExit
demods = modulation_utils.type_1_demods()
self.rx_path = usrp_receive_path.usrp_receive_path(
demods[options.modulation], callback, options)
self.connect(self.rx_path)
mods = modulation_utils.type_1_mods()
self.tx_path = usrp_transmit_path.usrp_transmit_path(
mods[options.modulation], options)
self.connect(self.tx_path)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling"
def __init__(self):
self.macAddr = 0
args = ["-f", "2.4G", "-R", "B", "-T", "B"]
demods = modulation_utils.type_1_demods()
mods = modulation_utils.type_1_mods()
parser = OptionParser(option_class=eng_option,
conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option(
"-m",
"--modulation",
type="choice",
choices=mods.keys(),
default='gmsk',
help="Select modulation from: %s [default=%%default]" %
(', '.join(mods.keys()), ))
usrp_transmit_path.add_options(parser, expert_grp)
usrp_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(args)
self.tb = my_top_block(demods[options.modulation],
mods[options.modulation], self.callback,
options)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print 'Warning: Failed to enable realtime scheduling.'
self.tb.start()
self.n_rcvd = 0
self.n_right = 0
self.pkt_no = 0
print "server init ok!"
def add_options(normal, expert):
"""
Adds usrp-specific options to the Options Parser
"""
add_freq_option(normal)
mods = modulation_utils.type_1_mods()
demods = modulation_utils.type_1_demods()
normal.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
default='gmsk',
help="Select modulation from: %s [default=%%default]"
% (', '.join(mods.keys()),))
#other necessary options
usrp_transmit_path.add_options(normal, expert)
usrp_receive_path.add_options(normal, expert)
for mod in mods.values():
mod.add_options(expert)
for demod in demods.values():
demod.add_options(expert)
def __init__(self, callback):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous")
transceiver.add_options(parser, expert_grp)
args = ['-f', '2.4G', '-u', '1', '-i', '64', '-d', '32']
(options, args) = parser.parse_args(args)
#init receive
self._rx_freq = options.rx_freq
self._rx_gain = options.rx_gain
self._rx_subdev_spec = options.rx_subdev_spec
self._decim = options.decim
#init transmit
self._tx_freq = options.tx_freq
self._tx_subdev_spec = options.tx_subdev_spec
self._interp = options.interp
#check receive
if self._rx_freq is None:
sys.stderr.write("-f FREQ or --freq FREQ or --rx-freq FREQ must be specified\n")
raise SystemExit
#check transmit
if self._tx_freq is None:
sys.stderr.write("-f FREQ or --freq FREQ or --rx-freq FREQ must be specified\n")
raise SystemExit
demods = modulation_utils.type_1_demods()
self.rx_path = usrp_receive_path.usrp_receive_path(demods[options.modulation], callback, options)
self.connect(self.rx_path)
mods = modulation_utils.type_1_mods()
self.tx_path = usrp_transmit_path.usrp_transmit_path(mods[options.modulation], options)
self.connect(self.tx_path)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling"
def __init__(self):
self.macAddr = 1
args = ["-f", "2.4G", "-R", "B", "-T", "B"]
demods = modulation_utils.type_1_demods()
mods = modulation_utils.type_1_mods()
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
default='gmsk',
help="Select modulation from: %s [default=%%default]"
% (', '.join(mods.keys()),))
usrp_transmit_path.add_options(parser, expert_grp)
usrp_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(args)
self.tb = my_top_block(demods[options.modulation], mods[options.modulation], self.callback, options)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print 'Warning: Failed to enable realtime scheduling.'
self.tb.start()
self.n_rcvd = 0
self.n_right = 0
self.pkt_no = 0
self.reqId = 0
print "client init ok!"
def add_options(normal, expert):
"""
Adds usrp-specific options to the Options Parser
"""
add_freq_option(normal)
mods = modulation_utils.type_1_mods()
demods = modulation_utils.type_1_demods()
normal.add_option(
"-m",
"--modulation",
type="choice",
choices=mods.keys(),
default='gmsk',
help="Select modulation from: %s [default=%%default]" %
(', '.join(mods.keys()), ))
#other necessary options
usrp_transmit_path.add_options(normal, expert)
usrp_receive_path.add_options(normal, expert)
for mod in mods.values():
mod.add_options(expert)
for demod in demods.values():
demod.add_options(expert)
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")
expert_grp.add_option("", "--rx-freq", type="eng_float", default=None,
help="set Rx frequency to FREQ [default=%default]", metavar="FREQ")
expert_grp.add_option("", "--tx-freq", type="eng_float", default=None,
help="set transmit frequency to FREQ [default=%default]", metavar="FREQ")
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("-b","--bssid", default="00:00:00:00:00:00",
help="set bssid for network in the form xx:xx:xx:xx:xx:xx") #ZLM copy form chenlong
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]")
parser.add_option("","--tun", action="store_true", default=False,
help="use tun device instead of tap to pass packets.") #ZLM copy form chenlong
expert_grp.add_option("","--tun-device-filename", default="/dev/net/tun",
help="path to tun device file [default=%default]")
usrp_transmit_path.add_options(parser, expert_grp)
usrp_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.stderr)
sys.exit(1)
bssid = validate_mac_addr(options.bssid)
if bssid == 0:
print "Invalid BSSID ", options.bssid
parser.print_help()
sys.exit(1)
mod_kwargs = {
'bt' : options.bt,
}
pkttype = 'eth'
tuntype = 'tap'
mcache = None
if options.tun:
pkttype = 'ip'
tuntype = 'tun'
# open the TUN/TAP interface
(tun_fd, tun_ifname) = open_tun_interface(tuntype, options.tun_device_filename)
tun_mac = get_mac_for_interface(tun_ifname)
mac_addr = validate_mac_addr(tun_mac)
if mac_addr == 0:
print "Invalid MAC address ", tun_mac, " for interface ", tun_ifname
print "exiting."
sys.exit(1)
if options.verbose:
print "Using MAC address ", tun_mac, " for interface ", 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"
# 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
numchan = 3
# instantiate the MACi
DC = [2.810e9,]
for i in range(numchan):
DC += [DC[i] + 0.002 * 10**9] #gen channel
QCH = makeQCH.makeQCH(numchan)[1] #gen QCH number
# QCH = [1,1,1,1,1,1,1,1,1]
mac = cs_mac(tun_fd, mac_addr, pkttype, bssid, mcache, DC, QCH, verbose=True)
# build the graph (PHY)
fg = my_graph(mods[options.modulation],demods[options.modulation],
mac.phy_rx_callback, options)
mac.set_flow_graph(fg) # 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" % (tb.txpath.interp(),)
#print "decim: %3d" % (tb.rxpath.decim(),)
fg.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
fg.start() # Start executing the flow graph (runs in separate threads)
f1 = open('reservation_time.txt','w')
f2 = open('reservation_slot.txt','w')
f3 = open('Qlearn.txt','w')
f4 = open('channel.txt','w')
# mac.main_loop(f1,f2,f3)
mac.main_loop(f1,f2,f3,f4) # don't expect this to return...
f1.close()
f2.close()
f3.close()
fg.stop() # but if it does, tell flow graph to stop.
fg.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
def rx_callback(ok, payload):
global n_rcvd, n_right
(pktno,) = struct.unpack('!H', payload[0:2])
(beacon_ID,) = struct.unpack('!H', payload[2:4])
#Added to catch t.o.d. from modified beacon
(t_mant1,) = struct.unpack('!H', payload[4:6])
(t_mant2,) = struct.unpack('!H', payload[6:8])
(t_mant3,) = struct.unpack('!H', payload[8:10])
(t_frac1,) = struct.unpack('!H', payload[10:12])
(t_frac2,) = struct.unpack('!H', payload[12:14])
(t_frac3,) = struct.unpack('!H', payload[14:16])
(t_frac4,) = struct.unpack('!H', payload[16:18])
t_str = (str(t_mant1)+str(t_mant2)+str(t_mant3)+'.'+str(t_frac1)+
str(t_frac2)+str(t_frac3)+str(t_frac4))
#Added to identify team in file
team_id = 1
#Added to collect time of arrival
toa = time.time()
n_rcvd += 1
if ok:
n_right += 1
print "ok = %5s pktno = %4d beacon_ID = %4d n_rcvd = %4d n_right = %4d" % (
ok, pktno, beacon_ID, n_rcvd, n_right)
os.system('echo ' + str(pktno) + ',' + str(beacon_ID) + '>> plb_data')
f = open('gui_beacon_data', 'w')
f.write(str(pktno))
f.close()
#new data string action
#beacon_pktno:beacon_ID:t.o.d.:field_team_ID:t.o.a.
data_string = (str(pktno)+':'+str(beacon_ID)+':'+t_str+
':'+str(team_id)+':'+("%.15f"%toa)+'\n')
#brand new file writing action
f1 = open('geolocation_data', 'a')
f1.write(data_string)
f1.close()
demods = modulation_utils.type_1_demods()
# Create Options Parser:
parser = OptionParser (option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=demods.keys(),
default='gmsk',
help="Select modulation from: %s [default=%%default]"
% (', '.join(demods.keys()),))
usrp_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.stderr)
sys.exit(1)
if options.rx_freq is None:
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
parser.print_help(sys.stderr)
sys.exit(1)
# build the graph
tb = my_top_block(demods[options.modulation], rx_callback, options)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: Failed to enable realtime scheduling."
tb.start() # start flow graph
tb.wait() # wait for it to finish
def run(shm):
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])
(beacon_pktno,) = struct.unpack('!H', payload[2:4])
(beacon_ID,) = struct.unpack('!H', payload[4:6])
(team_ID,) = struct.unpack('!H', payload[6:8])
(lon_mant,) = struct.unpack('!H', payload[8:10])
(lon_frac1,) = struct.unpack('!H', payload[10:12])
(lon_frac2,) = struct.unpack('!H', payload[12:14])
(lon_frac3,) = struct.unpack('!H', payload[14:16])
(lon_frac4,) = struct.unpack('!H', payload[16:18])
(lat_mant,) = struct.unpack('!H', payload[18:20])
(lat_frac1,) = struct.unpack('!H', payload[20:22])
(lat_frac2,) = struct.unpack('!H', payload[22:24])
(lat_frac3,) = struct.unpack('!H', payload[24:26])
(lat_frac4,) = struct.unpack('!H', payload[26:28])
n_rcvd += 1
if ok:
n_right += 1
print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % (
ok, pktno, n_rcvd, n_right)
print ""
print "plb beacon number: ", beacon_pktno
print "beacon ID: ", beacon_ID
print "team ID: ", team_ID
print "longitude: -%d.%d%d%d%d" %(lon_mant, lon_frac1, lon_frac2, lon_frac3, lon_frac4)
print "latitude: %d.%d%d%d%d" %(lat_mant, lat_frac1, lat_frac2, lat_frac3, lat_frac4)
# convert lat/lon from sting to float
longitude = '-' + str(lon_mant) + '.'+ str(lon_frac1) + str(lon_frac2) + str(lon_frac3) + str(lon_frac4)
latitude = str(lat_mant) + '.'+ str(lat_frac1) + str(lat_frac2) + str(lat_frac3) + str(lat_frac4)
coords = longitude + ',' + latitude
shm.push(coords)
demods = modulation_utils.type_1_demods()
# Create Options Parser:
parser = OptionParser (option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=demods.keys(),
default='gmsk',
help="Select modulation from: %s [default=%%default]"
% (', '.join(demods.keys()),))
usrp_receive_path.add_options(parser, expert_grp)
for mod in demods.values():
mod.add_options(expert_grp)
(options, args) = parser.parse_args ()
options.rx_freq = 468000000
options.bitrate = 125000
options.usrpx = 2
if len(args) != 0:
parser.print_help(sys.stderr)
sys.exit(1)
if options.rx_freq is None:
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
parser.print_help(sys.stderr)
sys.exit(1)
# build the graph
tb = my_top_block(demods[options.modulation], rx_callback, options)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: Failed to enable realtime scheduling."
tb.start() # start flow graph
tb.wait() # wait for it to finish
def main():
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
(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 = modulation_utils.type_1_demods()
mods = modulation_utils.type_1_mods()
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m",
"--modulation",
type="choice",
choices=mods.keys(),
default='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("-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 file for packet contents")
usrp_transmit_path.add_options(parser, expert_grp)
usrp_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)
if options.tx_freq is None or options.rx_freq is None:
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
parser.print_help(sys.stderr)
sys.exit(1)
tb = my_top_block(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()
# generate and send packets
nbytes = int(1e6 * options.megabytes)
n = 0
pktno = 0
pkt_size = int(options.size)
while n < nbytes:
if options.from_file is None:
data = (pkt_size - 2) * chr(pktno & 0xff)
else:
data = source_file.read(pkt_size - 2)
if data == '':
break
payload = struct.pack('!H', pktno & 0xffff) + data
send_pkt(payload)
n += len(payload)
sys.stderr.write('.')
time.sleep(0.01)
if options.discontinuous and pktno % 5 == 4:
time.sleep(1)
pktno += 1
send_pkt('', True)
tb.wait()
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")
expert_grp.add_option("", "--rx-freq", type="eng_float", default=None,
help="set Rx frequency to FREQ [default=%default]", metavar="FREQ")
expert_grp.add_option("", "--tx-freq", type="eng_float", default=None,
help="set transmit frequency to FREQ [default=%default]", metavar="FREQ")
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)
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_transmit_path.add_options(parser, expert_grp)
usrp_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.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 = 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)
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():
mac_addr = '00:00:00:00:00:01'
mac = senderMAC(mac_addr)
def send_pkt(payload):
tb.send_pkt(payload)
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)
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]")
parser.add_option("","--filename", default=None,
help="use file for packet contents")
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)
if options.filename is None:
print 'no file specified'
# 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)
# build the graph (PHY)
tb = my_top_block(mods[options.modulation],
demods[options.modulation],
mac.rx_callback,
options)
mac.set_tb(tb)
#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"
tb.start() # Start executing the flow graph (runs in separate threads)
f = open(options.filename,"rb")
bytesread = f.read(1318)
print "read bytes of size %u" % len(bytesread)
while len(bytesread)>0:
print "read bytes of size %u" % len(bytesread)
mac.Send(bytesread)
bytesread = f.read(1318)
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])
(beacon_ID, ) = struct.unpack('!H', payload[2:4])
#Added to catch t.o.d. from modified beacon
(t_mant1, ) = struct.unpack('!H', payload[4:6])
(t_mant2, ) = struct.unpack('!H', payload[6:8])
(t_mant3, ) = struct.unpack('!H', payload[8:10])
(t_frac1, ) = struct.unpack('!H', payload[10:12])
(t_frac2, ) = struct.unpack('!H', payload[12:14])
(t_frac3, ) = struct.unpack('!H', payload[14:16])
(t_frac4, ) = struct.unpack('!H', payload[16:18])
t_str = (str(t_mant1) + str(t_mant2) + str(t_mant3) + '.' +
str(t_frac1) + str(t_frac2) + str(t_frac3) + str(t_frac4))
#Added to identify team in file
team_id = 1
#Added to collect time of arrival
toa = time.time()
n_rcvd += 1
if ok:
n_right += 1
print "ok = %5s pktno = %4d beacon_ID = %4d n_rcvd = %4d n_right = %4d" % (
ok, pktno, beacon_ID, n_rcvd, n_right)
os.system('echo ' + str(pktno) + ',' + str(beacon_ID) + '>> plb_data')
f = open('gui_beacon_data', 'w')
f.write(str(pktno))
f.close()
#new data string action
#beacon_pktno:beacon_ID:t.o.d.:field_team_ID:t.o.a.
data_string = (str(pktno) + ':' + str(beacon_ID) + ':' + t_str + ':' +
str(team_id) + ':' + ("%.15f" % toa) + '\n')
#brand new file writing action
f1 = open('geolocation_data', 'a')
f1.write(data_string)
f1.close()
demods = modulation_utils.type_1_demods()
# Create Options Parser:
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m",
"--modulation",
type="choice",
choices=demods.keys(),
default='gmsk',
help="Select modulation from: %s [default=%%default]" %
(', '.join(demods.keys()), ))
usrp_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.stderr)
sys.exit(1)
if options.rx_freq is None:
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
parser.print_help(sys.stderr)
sys.exit(1)
# build the graph
tb = my_top_block(demods[options.modulation], rx_callback, options)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: Failed to enable realtime scheduling."
tb.start() # start flow graph
tb.wait() # wait for it to finish
def main():
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
(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 = modulation_utils.type_1_demods()
mods = modulation_utils.type_1_mods()
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
default='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("-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 file for packet contents")
usrp_transmit_path.add_options(parser, expert_grp)
usrp_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)
if options.tx_freq is None or options.rx_freq is None:
sys.stderr.write("You must specify -f FREQ or --freq FREQ\n")
parser.print_help(sys.stderr)
sys.exit(1)
tb = my_top_block(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()
# generate and send packets
nbytes = int(1e6 * options.megabytes)
n = 0
pktno = 0
pkt_size = int(options.size)
while n < nbytes:
if options.from_file is None:
data = (pkt_size - 2) * chr(pktno & 0xff)
else:
data = source_file.read(pkt_size - 2)
if data == '':
break;
payload = struct.pack('!H', pktno & 0xffff) + data
send_pkt(payload)
n += len(payload)
sys.stderr.write('.')
time.sleep(0.01)
if options.discontinuous and pktno % 5 == 4:
time.sleep(1)
pktno += 1
send_pkt('',True)
tb.wait()
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():
global n_rcvd, n_right
n_rcvd = 0
n_right = 0
def rx_callback(ok, payload):
global n_rcvd, n_right
(pktno, ) = struct.unpack('!H', payload[0:2])
n_rcvd += 1
if ok:
n_right += 1
print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % (
ok, pktno, n_rcvd, n_right)
# print payload[2:len(payload)]
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)")
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(
"",
"--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()
# generate and send packets
nbytes = int(1e6 * options.megabytes)
n = 0
pktno = 0
pkt_size = int(options.size)
while n < nbytes:
send_pkt(
struct.pack('!H', pktno & 0xffff) +
(pkt_size - 2) * chr(pktno & 0xff))
n += pkt_size
pktno += 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
(pktno,) = struct.unpack('!H', payload[0:2])
n_rcvd += 1
if ok:
n_right += 1
print "ok = %5s pktno = %4d n_rcvd = %4d n_right = %4d" % (
ok, pktno, n_rcvd, n_right)
# print payload[2:len(payload)]
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)")
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("", "--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()
# generate and send packets
nbytes = int(1e6 * options.megabytes)
n = 0
pktno = 0
pkt_size = int(options.size)
while n < nbytes:
send_pkt(struct.pack('!H', pktno & 0xffff) + (pkt_size - 2) * chr(pktno & 0xff))
n += pkt_size
pktno += 1
send_pkt(eof=True)
tb.wait()
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)
