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