def main():
mods = digital.modulation_utils.type_1_mods()
demods = digital.modulation_utils.type_1_demods()
node_types = {}
node_types["head"] = "head"
node_types["node"] = "node"
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]")
expert_grp.add_option("-d", "--data-pkt", type="intx", default=256,
help="specify the data(in bytes) per packet [default=%default]")
expert_grp.add_option("", "--samp-num", type="intx", default=8,
help="specify how many samples for each node at each round of acquisition [default=%default]")
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]")
parser.add_option("-l", "--loop-number", type="intx", default=1,
help="Specify how many sesning loop to be performed")
transmit_path.add_options(parser, expert_grp)
receive_path.add_options(parser, expert_grp)
uhd_receiver.add_options(parser)
uhd_transmitter.add_options(parser)
uhd_sensor.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 Control State Machine
csm = ctrl_st_machine(node_types[options.node_type], options.node_index, options.loop_number, options)
# instantiate the MAC
mac = cs_mac(csm, tun_fd, verbose=True)
# build the graph (PHY)
tb = my_top_block(node_types[options.node_type],
options.node_index,
mods[options.modulation],
demods[options.modulation],
mac.phy_rx_callback,
options)
csm.set_top_block(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"
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)
csm.start_sensing(options.samp_num) # start the round robin command
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