def __init__(self,Freq): global parser parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-s", "--size", type="eng_float", default=1024, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=10.0, help="set megabytes to transmit [default=%default]") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("","--from-file", default=None, help="use file for packet contents") parser.add_option("-e", "--interface", type="string", default="eth0", help="Select ethernet interface. Default is eth0") parser.add_option("-m", "--MAC_addr", type="string", default="", help="Select USRP2 by its MAC address.Default is auto-select") parser.add_option("-j", "--start", type="eng_float", default=1e7, help="Start ferquency [default = %default]") parser.add_option("-k", "--stop", type="eng_float", default=1e8,help="Stop ferquency [default = %default]") parser.add_option("", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS", help="time to delay (in seconds) after changing frequency[default=%default]") parser.add_option("", "--dwell-delay", type="eng_float",default=1e-3, metavar="SECS", help="time to dwell (in seconds) at a given frequncy[default=%default]") parser.add_option("-G", "--gain", type="eng_float", default=None,help="set gain in dB (default is midpoint)") parser.add_option("-s", "--fft-size", type="int", default=256, help="specify number of FFT bins [default=%default]")# changed default value(256) parser.add_option("-d", "--decim", type="intx", default=16, help="set decimation to DECIM [default=%default]") # changed default value(16) parser.add_option("-i", "--input_file", default="", help="radio input file",metavar="FILE") parser.add_option("-S", "--sense-bins", type="int", default=128, help="set number of bins in the OFDM block [default=%default]") usrp_transmit_path.add_options(parser, expert_grp) ofdm.ofdm_mod.add_options(parser, expert_grp) (self.options, self.args) = parser.parse_args () if len(self.args) != 0: parser.print_help() sys.exit(1) if self.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) self.options.tx_freq=Freq.value self.tb = transmit(self.options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling"
def __init__(self,Freq): global parser parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-s", "--size", type="eng_float", default=1024, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("","--from-file", default=None, help="use file for packet contents") parser.add_option("-e", "--interface", type="string", default="eth0", help="Select ethernet interface. Default is eth0") parser.add_option("-m", "--MAC_addr", type="string", default="", help="Select USRP2 by its MAC address.Default is auto-select") parser.add_option("-j", "--start", type="eng_float", default=1e7, help="Start ferquency [default = %default]") parser.add_option("-k", "--stop", type="eng_float", default=1e8,help="Stop ferquency [default = %default]") parser.add_option("", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS", help="time to delay (in seconds) after changing frequency[default=%default]") parser.add_option("", "--dwell-delay", type="eng_float",default=2e-3, metavar="SECS", help="time to dwell (in seconds) at a given frequncy[default=%default]") parser.add_option("-G", "--gain", type="eng_float", default=None,help="set gain in dB (default is midpoint)") parser.add_option("-s", "--fft-size", type="int", default=256, help="specify number of FFT bins [default=%default]")# changed default value(256) parser.add_option("-d", "--decim", type="intx", default=4, help="set decimation to DECIM [default=%default]") # changed default value(16) parser.add_option("-i", "--input_file", default="", help="radio input file",metavar="FILE") parser.add_option("-S", "--sense-bins", type="int", default=128, help="set number of bins in the OFDM block [default=%default]") usrp_transmit_path.add_options(parser, expert_grp) ofdm.ofdm_mod.add_options(parser, expert_grp) (self.options, self.args) = parser.parse_args () if len(self.args) != 0: parser.print_help() sys.exit(1) if self.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) self.options.tx_freq=Freq.value self.tb = transmit(self.options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling"
def __init__(self,Freq): global parser parser = OptionParser(option_class=eng_option, conflict_handler="resolve") parser.add_option("-a", "--args", type="string", default="", help="UHD device address [default=%default]") expert_grp = parser.add_option_group("Expert") parser.add_option("-s", "--size", type="eng_float", default=400, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("","--from-file", default=None, help="use file for packet contents") parser.add_option("-e", "--interface", type="string", default="eth0", help="Select ethernet interface. Default is eth0") parser.add_option("-m", "--MAC_addr", type="string", default="", help="Select USRP2 by its MAC address.Default is auto-select") parser.add_option("-j", "--start", type="eng_float", default=1e7, help="Start ferquency [default = %default]") parser.add_option("-k", "--stop", type="eng_float", default=1e8,help="Stop ferquency [default = %default]") parser.add_option("", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS", help="time to delay (in seconds) after changing frequency[default=%default]") parser.add_option("", "--dwell-delay", type="eng_float",default=1e-3, metavar="SECS", help="time to dwell (in seconds) at a given frequncy[default=%default]") parser.add_option("-G", "--gain", type="eng_float", default=None,help="set gain in dB (default is midpoint)") parser.add_option("-s", "--fft-size", type="int", default=512, help="specify number of FFT bins [default=%default]") parser.add_option("-d", "--decim", type="intx", default=16, help="set decimation to DECIM [default=%default]") parser.add_option("-i", "--input_file", default="", help="radio input file",metavar="FILE") parser.add_option("-S", "--sense-bins", type="int", default=128, help="set number of bins in the OFDM block [default=%default]") usrp_transmit_path.add_options(parser, expert_grp) ofdm.ofdm_mod.add_options(parser, expert_grp) (self.options, self.args) = parser.parse_args () #fd= os.open('/home/spann/Dropbox/spec_sense/fifo',os.O_RDONLY) # Open the named pipe to pass on the sensed info to the transmitter part if len(self.args) != 0: parser.print_help() sys.exit(1) #if self.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) self.options.tx_freq=Freq.value ###value to set when restarted hard coded ie not a command line option any more print "trying to open the source file",self.options.input_file #if self.options.input_file is not "": #print "reading from file:",self.options.input_file #global source_file #source_file = open(self.options.input_file, 'r') self.tb = transmit(self.options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling"
def __init__(self): # Creating the optionparser global parser parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-a", "--args", type="string", default="", help="UHD device address [default=%default]") parser.add_option("-s", "--size", type="eng_float", default=400, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("","--from-file", default=None, help="use file for packet contents") parser.add_option("-e", "--interface", type="string", default="eth0", help="Select ethernet interface. Default is eth0") parser.add_option("-m", "--MAC_addr", type="string", default="", help="Select USRP2 by its MAC address.Default is auto-select") parser.add_option("-j", "--start", type="eng_float", default=1e7, help="Start ferquency [default = %default]") parser.add_option("-k", "--stop", type="eng_float", default=1e8,help="Stop ferquency [default = %default]") parser.add_option("", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS", help="time to delay (in seconds) after changing frequency[default=%default]") parser.add_option("", "--dwell-delay", type="eng_float",default=20e-3, metavar="SECS", help="time to dwell (in seconds) at a given frequncy[default=%default]") parser.add_option("-G", "--gain", type="eng_float", default=None,help="set gain in dB (default is midpoint)") parser.add_option("-s", "--fft-size", type="int", default=256, help="specify number of FFT bins [default=%default]") parser.add_option("-d", "--decim", type="intx", default=16, help="set decimation to DECIM [default=%default]") parser.add_option("-i", "--input_file", default="", help="radio input file",metavar="FILE") parser.add_option("-S", "--sense-bins", type="int", default=128, help="set number of bins in the OFDM block [default=%default]") usrp_transmit_path.add_options(parser, expert_grp) ofdm.ofdm_demod.add_options(parser, expert_grp) (self.options, self.args) = parser.parse_args () #fd= os.open('/home/spann/Dropbox/spec_sense/fifo',os.O_RDONLY) # Open the named pipe to pass on the sensed info to the transmitter part if len(self.args) != 0: # if no arguments are given display help options parser.print_help() sys.exit(1) if self.options.tx_freq is None: # if transmitter frequency is not mentioned sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") #parser.print_help(sys.stderr) sys.exit(1) if self.options.from_file is not None: # if source file is mentioned source_file = open(options.from_file, 'r') self.tb = transmit(self.options) # Constructing the flowgraph with the given options r = gr.enable_realtime_scheduling() # Enable the real time scheduling for flowgraph to be able to run. if r != gr.RT_OK: # Checking error in the status of real time scheduling enabling. 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 main(): parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-t", "--runtime", type=int, default=900) parser.add_option("-s", "--size", type="intx", default=97, help="set packet size [default=%default]") parser.add_option("-p", "--spacing", type="eng_float", default=1, help="set packet spacing in time [default=%default]") parser.add_option("-r", "--sample_rate", type="eng_float", default=500000, help="limit sample rate to RATE in throttle (%default)") parser.add_option("-l", "--loss", type="eng_float", default=0.2, help="loss rate that white rate tolerates (%default)") parser.add_option("", "--snr", type="eng_float", default=30, help="set the SNR of the channel in dB [default=%default]") parser.add_option("","--sender", action="store_true", default=False) parser.add_option("", "--tx-ip", type="string", default="128.111.52.67", help="Trasmitter's IP, needed for over-Ethernet-ACKs [default=%default]") parser.add_option("", "--rx-ip", type="string", default="128.111.52.70", help="Receiver's IP, needed for over-Ethernet-ACKs [default=%default]") #parser.add_option("", "--rx-ip", type="string", default="2001:4200:7000:112:227:eff:fe1c:2428", help="Receiver's IP, needed for over-Ethernet-ACKs [default=%default]") parser.add_option("", "--rx-port", type="intx", default=2727, help="Receiver's listening port, needed for over-Ethernet-ACKs [default=%default]") parser.add_option("", "--ack-timeout", type="eng_float", default=1, help="ACK timeout in seconds [default=%default]") parser.add_option("-v", "--verbose", action="store_true", default=False) transmit_path.transmit_path.add_options(parser, expert_grp) receive_path.receive_path.add_options(parser, expert_grp) usrp_transmit_path.add_options(parser, expert_grp) usrp_receive_path.add_options(parser, expert_grp) flex_ofdm.ofdm_mod.add_options(parser, expert_grp) flex_ofdm.ofdm_demod.add_options(parser, expert_grp) (options, args) = parser.parse_args () top = top_class(options.loss, options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" top.start() # start flow graph if options.sender: top.run(options.runtime) top.wait() # wait for it to finish
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(): def send_pkt(payload='', eof=False): return tb.txpath.send_pkt(payload, eof) def rx_callback(ok, payload): print "ok = %r, payload = '%s'" % (ok, payload) 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") parser.add_option("","--location", type="string", default = "[-80.422221051169391, 37.233082631938416]", help="set radio location in [lon, lat] (default=%default)") usrp_transmit_path.add_options(parser, expert_grp) for mod in mods.values(): mod.add_options(expert_grp) (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() sys.exit(1) if options.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.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 team_ID = 30376 n = 0 pktno = 0 pkt_size = int(options.size) f = open('plb_data','r') all_lines = f.readlines() f.close() os.system('cat /dev/null > plb_data') all_lines = "".join(all_lines) all_lines = all_lines.split("\n") all_lines.pop() payload4 = struct.pack('!H', team_ID & 0xffff) # original location # '[-80.422221051169391, 37.233082631938416]' loc_payload = format_loc(options.location) for n in all_lines: n = n.split(',') data = (pkt_size - 28) * chr(pktno & 0xff) payload1 = struct.pack('!H', pktno & 0xffff) payload2 = struct.pack('!H', int(n[0]) & 0xffff) payload3 = struct.pack('!H', int(n[1]) & 0xffff) payload = payload1 + payload2 + payload3 + payload4 + loc_payload + data send_pkt(payload) sys.stderr.write('.') if options.discontinuous and pktno % 5 == 4: time.sleep(1) pktno += 1 if pktno % 20 == 0: print "\npktno: %d \n" %pktno print "last location: ", options.location os.system('echo ' + options.location + ' > last_location') print "finished transmitting" # import all data from file # # send out all pkt numbers # fin send_pkt(eof=True) 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, acked n_rcvd = 0 n_right = 0 acked = threading.Event() def send_pkt(payload='', eof=False, seqno=0): return tb.txpath.send_pkt(payload, eof, seqno) def rx_callback(ok, payload, int_fo, frac_fo, time_sinr, freq_sinr, ch_gain, avg_gain): global n_rcvd, n_right n_rcvd += 1 try: (pktno,) = struct.unpack('!H', payload[0:2]) except: pktno = 1 if ok: n_right += 1 print "ok: %r \t pktno: %d \t n_rcvd: %d \t n_right: %d" % (ok, pktno, n_rcvd, n_right) freq_offset = int_fo+frac_fo/math.pi print "freq offset: %+.2f(subcarriers) \t SINR: %.2f(time domain), %.2f(freq domain)" % (freq_offset, time_sinr, freq_sinr) #print "Channel gain: "+str(ch_gain) #print "Average gain: "+str(avg_gain) if 1: printlst = list() for x in payload[2:]: t = hex(ord(x)).replace('0x', '') if(len(t) == 1): t = '0' + t printlst.append(t) printable = ''.join(printlst) print printable print "\n" acked.set() parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option ("-t", "--runtime", type=int, default=4) parser.add_option("-s", "--size", type="intx", default=95, help="set packet size [default=%default]") parser.add_option("-p", "--spacing", type="eng_float", default=1, help="set packet spacing in time [default=%default]") parser.add_option("-r", "--sample_rate", type="eng_float", default=500000, help="limit sample rate to RATE in throttle (%default)") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("", "--snr", type="eng_float", default=30, help="set the SNR of the channel in dB [default=%default]") my_top_block.add_options(parser, expert_grp) transmit_path.transmit_path.add_options(parser, expert_grp) receive_path.receive_path.add_options(parser, expert_grp) usrp_transmit_path.add_options(parser,expert_grp) flex_ofdm.ofdm_mod.add_options(parser, expert_grp) flex_ofdm.ofdm_demod.add_options(parser, expert_grp) (options, args) = parser.parse_args () # build the graph tb = my_top_block(rx_callback, options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" tb.start() # start flow graph start_time = time.time() # generate and send infinite stream of packets, will be # interrupted by runtime n = 0 pktno = 0 pkt_size = int(options.size) #while time.time() < start_time + options.runtime: while pktno < options.runtime: send_pkt(pkt_size * chr(0x05), eof=False, seqno=pktno) n += pkt_size #sys.stderr.write('.') pktno += 1 print "sent %d packets" % (pktno,) #time.sleep(0.1) acked.wait(3) acked.clear() time.sleep(options.spacing) #acked.wait() if (pktno == 110): options.tone_map = "1fffffffffffe7fffffffffff8" tb.reset_ofdm_params(options.tone_map, "bpsk") send_pkt(eof=True) print "\nfinishing: sent %d packets" % (pktno,) #raise SystemExit tb.wait() # wait for it to finish
def main(): def send_pkt(payload='', eof=False): return tb.txpath.send_pkt(payload, eof) def rx_callback(ok, payload): print "ok = %r, payload = '%s'" % (ok, payload) 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) 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.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.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) try: 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 except KeyboardInterrupt: pass send_pkt(eof=True) tb.stop() tb.wait() # wait for it to finish
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(): def send_pkt(payload='', eof=False): return tb.txpath.send_pkt(payload, eof) def rx_callback(ok, payload): print "ok = %r, payload = '%s'" % (ok, payload) 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("-M", "--megabytes", type="eng_float", default=0, help="set megabytes to transmit [default=inf]") parser.add_option("-I", "--audio-input", type="string", default="", help="pcm input device name. E.g., hw:0,0 or /dev/dsp") usrp_transmit_path.add_options(parser, expert_grp) for mod in mods.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.exit(1) if options.tx_freq is None: sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") parser.print_help(sys.stderr) sys.exit(1) # build the 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 while nbytes == 0 or n < nbytes: packet = tb.audio_rx.get_encoded_voice_packet() s = packet.to_string() send_pkt(s) n += len(s) sys.stderr.write('.') pktno += 1 send_pkt(eof=True) tb.wait() # wait for it to finish
def main(): def send_pkt(payload='', carrier_map="FE7F", eof=False): return tb.txpath.send_pkt(payload, eof, carrier_map) parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-s", "--size", type="eng_float", default=1024, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser.add_option("", "--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("", "--from-file", default=None, help="use file for packet contents") usrp_transmit_path.add_options(parser, expert_grp) ofdm.ofdm_mod.add_options(parser, expert_grp) (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) if 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.from_file is not None: source_file = open(options.from_file, 'r') tb = my_top_block(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 # variables used in transmission nbytes = int(10e6 * options.megabytes) # Total number of bytes to be sent. n = 0 pktno = 0 pkt_size = int(options.size) # Packet size # udata ="Transmission is success" # string which is to be sent # Added Line # print "udata",udata # Added Line source_file = open("/home/kranthi/tx1.txt", 'r') # Source file location # Added Line # source_file = open(options.from_file,'r') # Added Line file_size = os.path.getsize("/home/kranthi/tx1.txt") print file_size no_packets = math.ceil(file_size / pkt_size) print no_packets preamble = 0 while n < nbytes: if (pktno < 20): data = "This is Garbage data" else: data = source_file.read(pkt_size - 2) # data from the file # Original Line if data == '': break payload = struct.pack('!H', pktno & 0xffff) + struct.pack( '!H', preamble & 0xffff ) + data # Constructing a packet. Pack a string in to given format. http://docs.python.org/library/struct.html send_pkt(payload) # Sending packet n += len(payload) sys.stderr.write('.') # error message if options.discontinuous and pktno % 5 == 4: # if discontinuous mode is selected pass for 1 sec after every 4 byte transmission. time.sleep(1) pktno += 1 send_pkt(eof=True) tb.wait()
def main(): def send_pkt(payload='',carrier_map="FE7F",eof=False): return tb.txpath.send_pkt(payload, eof,carrier_map) parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-s", "--size", type="eng_float", default=1024, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("","--from-file", default=None, help="use file for packet contents") usrp_transmit_path.add_options(parser, expert_grp) ofdm.ofdm_mod.add_options(parser, expert_grp) (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() sys.exit(1) if 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.from_file is not None: source_file = open(options.from_file, 'r') tb = my_top_block(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 # variables used in transmission nbytes = int(10e6 * options.megabytes) # Total number of bytes to be sent. n = 0 pktno = 0 pkt_size = int(options.size) # Packet size # udata ="Transmission is success" # string which is to be sent # Added Line # print "udata",udata # Added Line source_file = open("/home/kranthi/tx1.txt",'r') # Source file location # Added Line # source_file = open(options.from_file,'r') # Added Line file_size = os.path.getsize("/home/kranthi/tx1.txt") print file_size no_packets = math.ceil(file_size/pkt_size) print no_packets preamble = 0 while n < nbytes: if (pktno < 20): data = "This is Garbage data" else: data = source_file.read(pkt_size - 2)# data from the file # Original Line if data == '': break; payload = struct.pack('!H', pktno & 0xffff) + struct.pack('!H', preamble & 0xffff) + data # Constructing a packet. Pack a string in to given format. http://docs.python.org/library/struct.html send_pkt(payload) # Sending packet n += len(payload) sys.stderr.write('.') # error message if options.discontinuous and pktno % 5 == 4: # if discontinuous mode is selected pass for 1 sec after every 4 byte transmission. time.sleep(1) pktno += 1 send_pkt(eof=True) tb.wait()
def __init__(self): # Creating the optionparser global parser parser = OptionParser(option_class=eng_option, conflict_handler="resolve") expert_grp = parser.add_option_group("Expert") parser.add_option("-a", "--args", type="string", default="", help="UHD device address [default=%default]") parser.add_option("-s", "--size", type="eng_float", default=400, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser.add_option("", "--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("", "--from-file", default=None, help="use file for packet contents") parser.add_option("-e", "--interface", type="string", default="eth0", help="Select ethernet interface. Default is eth0") parser.add_option( "-m", "--MAC_addr", type="string", default="", help="Select USRP2 by its MAC address.Default is auto-select") parser.add_option("-j", "--start", type="eng_float", default=1e7, help="Start ferquency [default = %default]") parser.add_option("-k", "--stop", type="eng_float", default=1e8, help="Stop ferquency [default = %default]") parser.add_option( "", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS", help= "time to delay (in seconds) after changing frequency[default=%default]" ) parser.add_option( "", "--dwell-delay", type="eng_float", default=20e-3, metavar="SECS", help= "time to dwell (in seconds) at a given frequncy[default=%default]") parser.add_option("-G", "--gain", type="eng_float", default=None, help="set gain in dB (default is midpoint)") parser.add_option("-s", "--fft-size", type="int", default=256, help="specify number of FFT bins [default=%default]") parser.add_option("-d", "--decim", type="intx", default=16, help="set decimation to DECIM [default=%default]") parser.add_option("-i", "--input_file", default="", help="radio input file", metavar="FILE") parser.add_option( "-S", "--sense-bins", type="int", default=128, help="set number of bins in the OFDM block [default=%default]") usrp_transmit_path.add_options(parser, expert_grp) ofdm.ofdm_demod.add_options(parser, expert_grp) (self.options, self.args) = parser.parse_args() #fd= os.open('/home/spann/Dropbox/spec_sense/fifo',os.O_RDONLY) # Open the named pipe to pass on the sensed info to the transmitter part if len(self.args ) != 0: # if no arguments are given display help options parser.print_help() sys.exit(1) if self.options.tx_freq is None: # if transmitter frequency is not mentioned sys.stderr.write("You must specify -f FREQ or --freq FREQ\n") #parser.print_help(sys.stderr) sys.exit(1) if self.options.from_file is not None: # if source file is mentioned source_file = open(options.from_file, 'r') self.tb = transmit( self.options) # Constructing the flowgraph with the given options r = gr.enable_realtime_scheduling( ) # Enable the real time scheduling for flowgraph to be able to run. if r != gr.RT_OK: # Checking error in the status of real time scheduling enabling. print "Warning: failed to enable realtime scheduling"
def __init__(self, Freq): global parser parser = OptionParser(option_class=eng_option, conflict_handler="resolve") parser.add_option("-a", "--args", type="string", default="", help="UHD device address [default=%default]") expert_grp = parser.add_option_group("Expert") parser.add_option("-s", "--size", type="eng_float", default=400, help="set packet size [default=%default]") parser.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser.add_option("", "--discontinuous", action="store_true", default=False, help="enable discontinuous mode") parser.add_option("", "--from-file", default=None, help="use file for packet contents") parser.add_option("-e", "--interface", type="string", default="eth0", help="Select ethernet interface. Default is eth0") parser.add_option( "-m", "--MAC_addr", type="string", default="", help="Select USRP2 by its MAC address.Default is auto-select") parser.add_option("-j", "--start", type="eng_float", default=1e7, help="Start ferquency [default = %default]") parser.add_option("-k", "--stop", type="eng_float", default=1e8, help="Stop ferquency [default = %default]") parser.add_option( "", "--tune-delay", type="eng_float", default=1e-3, metavar="SECS", help= "time to delay (in seconds) after changing frequency[default=%default]" ) parser.add_option( "", "--dwell-delay", type="eng_float", default=1e-3, metavar="SECS", help= "time to dwell (in seconds) at a given frequncy[default=%default]") parser.add_option("-G", "--gain", type="eng_float", default=None, help="set gain in dB (default is midpoint)") parser.add_option("-s", "--fft-size", type="int", default=512, help="specify number of FFT bins [default=%default]") parser.add_option("-d", "--decim", type="intx", default=16, help="set decimation to DECIM [default=%default]") parser.add_option("-i", "--input_file", default="", help="radio input file", metavar="FILE") parser.add_option( "-S", "--sense-bins", type="int", default=128, help="set number of bins in the OFDM block [default=%default]") usrp_transmit_path.add_options(parser, expert_grp) ofdm.ofdm_mod.add_options(parser, expert_grp) (self.options, self.args) = parser.parse_args() #fd= os.open('/home/spann/Dropbox/spec_sense/fifo',os.O_RDONLY) # Open the named pipe to pass on the sensed info to the transmitter part if len(self.args) != 0: parser.print_help() sys.exit(1) #if self.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) self.options.tx_freq = Freq.value ###value to set when restarted hard coded ie not a command line option any more print "trying to open the source file", self.options.input_file #if self.options.input_file is not "": #print "reading from file:",self.options.input_file #global source_file #source_file = open(self.options.input_file, 'r') self.tb = transmit(self.options) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling"
def main(): time.sleep(5) def send_pkt(payload='', eof=False): return tb.txpath.send_pkt(payload, eof) def rx_callback(ok, payload): print "ok = %r, payload = '%s'" % (ok, payload) 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) 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.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.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 f = open('beacon_id', 'r') lines = f.readlines() f.close() if not (len(lines) == 0): item = lines.pop(0) beacon_ID = int(item.strip('[]\n')) else: beacon_ID = 909 nbytes = int(1e6 * options.megabytes) n = 0 pktno = 0 pkt_size = int(options.size) while n < nbytes: #18 is new, old value was 4 if options.from_file is None: data = (pkt_size - 18) * chr(pktno & 0xff) else: data = source_file.read(pkt_size - 2) if data == '': break payload1 = struct.pack('!H', pktno & 0xffff) payload2 = struct.pack('!H', beacon_ID & 0xffff) #time magic t = "%.15f" % time.time() t = t.split('.') t_mant = t[0] t_frac = t[1] payload3 = struct.pack('!H', int(t_mant[0:4]) & 0xffff) payload4 = struct.pack('!H', int(t_mant[4:8]) & 0xffff) payload5 = struct.pack('!H', int(t_mant[8:len(t_mant)]) & 0xffff) payload6 = struct.pack('!H', int(t_frac[0:4]) & 0xffff) payload7 = struct.pack('!H', int(t_frac[4:8]) & 0xffff) payload8 = struct.pack('!H', int(t_frac[8:12]) & 0xffff) payload9 = struct.pack('!H', int(t_frac[12:len(t_frac)]) & 0xffff) #payloads added here as well payload = (payload1 + payload2 + payload3 + payload4 + payload5 + payload6 + payload7 + payload8 + payload9 + 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
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(): def send_pkt(payload='', eof=False): return tb.txpath.send_pkt(payload, eof) def rx_callback(ok, payload): print "ok = %r, payload = '%s'" % (ok, payload) 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") parser.add_option( "", "--location", type="string", default="[-80.422221051169391, 37.233082631938416]", help="set radio location in [lon, lat] (default=%default)") usrp_transmit_path.add_options(parser, expert_grp) for mod in mods.values(): mod.add_options(expert_grp) (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() sys.exit(1) if options.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.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 team_ID = 30376 n = 0 pktno = 0 pkt_size = int(options.size) f = open('plb_data', 'r') all_lines = f.readlines() f.close() os.system('cat /dev/null > plb_data') all_lines = "".join(all_lines) all_lines = all_lines.split("\n") all_lines.pop() payload4 = struct.pack('!H', team_ID & 0xffff) # original location # '[-80.422221051169391, 37.233082631938416]' loc_payload = format_loc(options.location) for n in all_lines: n = n.split(',') data = (pkt_size - 28) * chr(pktno & 0xff) payload1 = struct.pack('!H', pktno & 0xffff) payload2 = struct.pack('!H', int(n[0]) & 0xffff) payload3 = struct.pack('!H', int(n[1]) & 0xffff) payload = payload1 + payload2 + payload3 + payload4 + loc_payload + data send_pkt(payload) sys.stderr.write('.') if options.discontinuous and pktno % 5 == 4: time.sleep(1) pktno += 1 if pktno % 20 == 0: print "\npktno: %d \n" % pktno print "last location: ", options.location os.system('echo ' + options.location + ' > last_location') print "finished transmitting" # import all data from file # # send out all pkt numbers # fin send_pkt(eof=True) tb.wait() # wait for it to finish
def main(): global stats_array, count_array, time_array, n_rcvd global n_right, sync_status, mode, ch, data_packet_delivery_count global n_attempts data_packet_delivery_count_previous = 0 n_rcvd = 0 n_right = 0 n_attempts = 5 threshold = 0.01 count_array = [ 0, 0, 0, 0, 0] time_array = [ 0, 0, 0, 0, 0] stats_array = [ 0, 0, 0, 0, 0,0,0,0,0,0,0,0,0,0,0] def send_pkt(self, payload='', eof=False): return self.txpath.send_pkt(payload, eof) def get_freq_rx(): return 2.44*1e9 def get_freq_tx(): # return 8,900e6 # Convert hop_freq to our unique channel list channel = int(random.choice([1,7])) hop_freq = float(1e6 * (850+(channel-1)*5))#setting the centre freq frequency for sending packets stats_array[channel] = stats_array[channel] + 1 print "\nChannel DSA Selection Statistics (Channel #: Number times selected)" print "1: ", stats_array[1], " 7: ",stats_array[7] return channel,hop_freq #returning the channel number and hop frequency def rx_callback(ok, payload): global n_rcvd, n_right,sync_status,mode,ch,data_packet_delivery_count ########################## sync #################################### if mode == "sync": if ok: print "SYNC:GOT CHANNEL PACKET" (pktno,) = struct.unpack('!H', payload[0:2]) (sync_signal,) = struct.unpack('!s', payload[2]) (data_channel,) = struct.unpack('!H', payload[3:5]) if str(sync_signal) == 'o' and str(data_channel) == str(ch): sync_status = True #tb.stop() print "SYNC:RECEIVE CONFIRM PACKET...LINK ESTABLISHED" if str(sync_signal) == 's' and str(data_channel) == str(ch): print "SYNC:SEND CONFIRM PACKET" sync_status = True data = 'o' pktno=0 ack_payload = struct.pack('!HsH', pktno & 0xffff,data,ch & 0xffff) #+ data send_pkt(tb,ack_payload) #sending back the acknowledgement ################################################################### ######################### traffic ################################# if mode == "traffic": if ok: (data_header,) = struct.unpack('!s', payload[0]) if data_header == 'd': #print "TRAFFIC:SEND ACK" data_packet_delivery_count = data_packet_delivery_count +1 comm = struct.unpack('!14s', payload[1:15]) data = 'dI am fine.....' #Sending this message payload = struct.pack('!15s', data) send_pkt(tb,payload) ############################################################## n_rcvd += 1 if ok: n_right += 1 mods = digital.modulation_utils.type_1_mods() demods = digital.modulation_utils.type_1_demods() #setting up the tx options parser parser_tx = OptionParser(option_class=eng_option, conflict_handler="resolve") parser_tx.add_option("-m", "--modulation", type="choice", choices=mods.keys(), default='gmsk',help="Select modulation from: %s [default=%%default]" % (', '.join(mods.keys()),)) parser_tx.add_option("-s", "--size", type="eng_float", default=1500, help="set packet size [default=%default]") parser_tx.add_option("-M", "--megabytes", type="eng_float", default=1.0, help="set megabytes to transmit [default=%default]") parser_tx.add_option("","--discontinuous", action="store_true", default=False, help="enable discontinous transmission (bursts of 5 packets)") parser_tx.add_option("","--from-file", default=None, help="use file for packet contents") expert_grp_tx = parser_tx.add_option_group("Expert_tx") dsa_grp = parser_tx.add_option_group("DSA Options") dsa_grp.add_option("-T", "--threshold", type="eng_float", default=0.01, help="set primary user sensing energy threshold [default=%default]") usrp_transmit_path.add_options(parser_tx, expert_grp_tx) parser_tx.remove_option('-f'); #parser_tx.remove_option('--tx-freq'); for mod in mods.values(): mod.add_options(expert_grp_tx) (options_tx, args_tx) = parser_tx.parse_args () if len(args_tx) != 0: parser_tx.print_help() sys.exit(1) ############# Setting some default values for tx side of the block options_tx.tx_freq = 900e6 options_tx.samples_per_symbol = 2 options_tx.modulation = 'gmsk' options_tx.fusb_block_size = 4096 options_tx.fusb_nblocks = 16 options_tx.bitrate = 0.0125e6 ############# parser_rx = OptionParser (option_class=eng_option, conflict_handler="resolve") expert_grp_rx = parser_rx.add_option_group("Expert_rx") usrp_receive_path.add_options(parser_rx, expert_grp_rx) parser_rx.remove_option('-f'); (options_rx, args_rx) = parser_rx.parse_args () ############# Setting some default values for rx side of the block options_rx.rx_freq = 2.44e9 #setting default rx_freq value options_rx.samples_per_symbol = 2 options_rx.modulation = 'gmsk' options_rx.fusb_block_size = 4096 options_rx.fusb_nblocks = 16 options_rx.bitrate = 0.0125e6 ############# print "[[ Using the RANDOM channel selection algorithm ]]\n\n" # build the graph tb = my_top_block(mods[options_tx.modulation], demods[options_rx.modulation], rx_callback,options_tx, options_rx) r = gr.enable_realtime_scheduling() if r != gr.RT_OK: print "Warning: failed to enable realtime scheduling" tb.start() #listening to random frequencies untill a match is found running = True # Scan all channels first for inital data #time.sleep(0.1) print "\n[[ Scanning channels for network nodes ]]\n" timeout = time.time() + timer while running: if time.time() > timeout: break ################################################sync mode#################################### if mode == "sync": if sync_status != True: ch,hop_freq = get_freq_tx() hop_freq_rx = get_freq_rx() tb.txpath.sink.set_freq(hop_freq) tb.rxpath.source.set_freq(hop_freq_rx) print "RX_FREQ:",hop_freq_rx," TX_FREQ:",hop_freq ch_energy = level(ch) #check if primary user is present #print ch_energy,"*"*30 if int(ch_energy) > threshold: #if primary user is there then dont transmit on this channel time.sleep(1) continue nbytes = 5 #int(1e6 * .0003) pkt_size = 5 n = 0 pktno = 0 while n < nbytes: if options_tx.from_file is None: data = 's' else: data = source_file.read(pkt_size - 2) if data == '': break; payload = struct.pack('!HsH', pktno & 0xffff,data,ch & 0xffff) #+ data send_pkt(tb,payload) n += len(payload) sys.stderr.write("SEND SYNC PACKET\n") if options_tx.discontinuous and pktno % 5 == 4: time.sleep(1) pktno += 1 time.sleep(1) else: print "\n\n[[ Network Node Found: Commencing communications on CHANNEL ", ch, " ]]\n"; n_attempts_counter = 0 mode = "traffic" data_packet_delivery_count = 0 sync_status="False" start_time = datetime.now() #measuring the time for which the primary user is away ################################################end of sync mode#################################### ################################################Communications mode################################# if mode == "traffic": nbytes = 15 pkt_size = 15 data_pktno = 0 n = 0 while n < nbytes: if options_tx.from_file is None: data = 'dHi how are you' #Sending this message else: data = source_file.read(pkt_size - 2) if data == '': break; payload = struct.pack('!15s', data) send_pkt(tb,payload) n += len(payload) sys.stderr.write("SEND TRAFFIC PACKET\n") if options_tx.discontinuous and data_pktno % 5 == 4: time.sleep(1) data_pktno += 1 time.sleep(0.2 + 0.05*int(random.choice([0,1,2,3]))) if data_packet_delivery_count == data_packet_delivery_count_previous: #checking if the data packet delivery has stagnated n_attempts_counter += 1 if n_attempts_counter > n_attempts: #get out of the data channel as it seems that the other node is still trying to rendezvous mode = "sync" continue else: data_packet_delivery_count_previous = 0 data_packet_delivery_count = 0 data_packet_delivery_count_previous = data_packet_delivery_count ch_energy = level(ch) #check if primary user is present print "CHANNEL ENERGY:",ch_energy,"\n" if int(ch_energy) > threshold: #if primary user is there then dont transmit on this channel stop_time = datetime.now() _elapsed_time = start_time - stop_time print "\n[[ Primary User Detected: Evacuating Current Channel ]]\n" print "\n[[ Scanning channels for network nodes ]]\n" print "\nAbsent time:",_elapsed_time,"\n" mode = "sync"
def main(): def send_pkt(payload='', eof=False): return tb.txpath.send_pkt(payload, eof) def rx_callback(ok, payload): print "ok = %r, payload = '%s'" % (ok, payload) 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) 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.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.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('.') time.sleep(0.01) if options.discontinuous and pktno % 5 == 4: time.sleep(1) pktno += 1 send_pkt(eof=True) tb.wait() # wait for it to finish
def main(): def send_pkt(payload=None, eof=False): return tb.txpath.send_pkt(payload, eof) def rx_callback(ok, payload): print "ok = %r, payload = '%s'" % (ok, payload) mods = modulation_utils.type_1_mods() print "mods: ",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='dbpsk', #'dbpsk', need to add SNR stuff from 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) 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.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.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) nbytes = 100 n = 0 pktno = 0 pkt_size = int(options.size) f = open('/home/georgios_colleen/gnuradio/gnuradio-examples/python/digital/sent.txt', 'a') filedone=False while pktno < nbytes: #why are we limiting to 100 pkts being sent??? print("---------------------pktno = %i, nbytes = %i--------------------"%(pktno,nbytes)) if options.from_file is None: data = (pkt_size - 2) * chr(pktno & 0xff) elif not(filedone): fromfile = source_file.read(pkt_size - 2) print("fromfile = %s\n"%fromfile) if fromfile == '': filedone = True continue data = fromfile#recode(fromfile) f.write(fromfile+"\n") elif len(packet_utils2.coded) > 0: print("CALLING WITH NO PAYLOAD") send_pkt(None) continue else: break #we really, truly have nothing left to send #struct.pack(fmt, v1, v2, ...) #Return a string containing the values v1, v2, ... payload = struct.pack('!H', pktno & 0xffff) + data print type(data)#struct.pack('!H', pktno & 0xffff)#payload send_pkt(payload) print("returned from send_pkt") n += len(payload) sys.stderr.write('.') if options.discontinuous and pktno % 10 == 9: time.sleep(1) pktno += 1 time.sleep(3) print("About to send EOF") send_pkt(eof=True) tb.wait() # wait for it to finish