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
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)
mods = digital.modulation_utils.type_1_mods()
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
expert_grp = parser.add_option_group("Expert")
parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
default='psk',
help="Select modulation from: %s [default=%%default]"
% (', '.join(mods.keys()),))
parser.add_option("-s", "--size", type="eng_float", default=1500,
help="set packet size [default=%default]")
parser.add_option("-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")
transmit_path.add_options(parser, expert_grp)
uhd_transmitter.add_options(parser)
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')
# build the graph
tb = my_top_block(mods[options.modulation], options)
r = gr.enable_realtime_scheduling()
if r != gr.RT_OK:
print "Warning: failed to enable realtime scheduling"
tb.start() # start flow graph
# generate and send packets
nbytes = int(1e6 * options.megabytes)
n = 0
pktno = 0
pkt_size = int(options.size)
while n < nbytes:
if options.from_file is None:
data = (pkt_size - 2) * chr(pktno & 0xff)
else:
data = source_file.read(pkt_size - 2)
if data == '':
break;
payload = struct.pack('!H', pktno & 0xffff) + data
send_pkt(payload)
n += len(payload)
sys.stderr.write('.')
if options.discontinuous and pktno % 5 == 4:
time.sleep(1)
pktno += 1
send_pkt(eof=True)
tb.wait() # wait for it to finish