Beispiel #1
0
    def __init__(self, callback, options):
        gr.top_block.__init__(self)

        self.source = uhd_receiver(
            options.args,
            options.bandwidth,
            options.rx_freq,
            options.rx_gain,
            options.spec,
            options.antenna,
            options.verbose,
        )

        self.sink = uhd_transmitter(
            options.args,
            options.bandwidth,
            options.tx_freq,
            options.tx_gain,
            options.spec,
            options.antenna,
            options.verbose,
        )

        self.txpath = transmit_path(options)
        self.rxpath = receive_path(callback, options)

        self.connect(self.txpath, self.sink)
        self.connect(self.source, self.rxpath)
    def __init__(self, options):
        gr.top_block.__init__(self)

        if options.outfile is not None:
          u = gr.file_sink(gr.sizeof_gr_complex, options.outfile)
        elif (options.tx_freq is not None) or (options.channel is not None):
          if options.channel is not None:
            self.chan_num = options.channel
            options.tx_freq = ieee802_15_4_pkt.chan_802_15_4.chan_map[self.chan_num]

          u = uhd_transmitter(options.tx_args,
                              options.bandwidth,
                              options.tx_freq, options.tx_gain,
                              options.spec, options.antenna,
                              options.verbose, options.external)
        else:
          raise SystemExit("--tx-freq, --channel or --outfile must be specified\n")

        self.samples_per_symbol = 2

        # transmitter
        self.packet_transmitter = ieee802_15_4_pkt.ieee802_15_4_mod_pkts(self,
                spb=self.samples_per_symbol, msgq_limit=2, log=options.log)
        self.amp = gr.multiply_const_cc(1)

        self.u = u
        self.connect(self.packet_transmitter, self.amp, self.u)

        self.connect(self.amp, gr.file_sink(gr.sizeof_gr_complex, 'cc2420-tx-diag.dat'))
Beispiel #3
0
    def __init__(self, options, payload=''):
        gr.top_block.__init__(self)

	if(options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args,
                                        options.bandwidth,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
        elif(options.to_file is not None):
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

	options.interp	= 100e6/options.bandwidth	# FTW-specific convertion

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        if(options.from_file is None):
            self.txpath = ftw_transmit_path(options, payload)    
        else:
            self.txpath = gr.file_source(gr.sizeof_gr_complex, options.from_file);
#            options.tx_amplitude = 1

        # static value to make sure we do not exceed +-1 for the floats being sent to the sink
	self._tx_amplitude = options.tx_amplitude        
	self.amp = gr.multiply_const_cc(self._tx_amplitude)

        # self.txpath = ftw_pnc_transmit_path(options, payload)
        self.connect(self.txpath, self.amp, self.sink)

        if options.log:
            self.connect(self.txpath, gr.file_sink(gr.sizeof_gr_complex, 'ftw_benchmark.dat'))
Beispiel #4
0
    def __init__(self, modulator_class, options):
        gr.top_block.__init__(self)
        self.txpath = transmit_path(modulator_class, options)
        self.audio_rx = audio_rx(options.audio_input)

        if(options.tx_freq is not None):
            self.sink = uhd_transmitter(options.address, options.bitrate,
                                        options.samples_per_symbol,
                                        options.tx_freq, options.tx_gain,
                                        options.antenna, options.verbose)
            options.samples_per_symbol = self.sink._sps
            audio_rate = self.audio_rx.sample_rate
            usrp_rate = self.sink.get_sample_rate()
            rrate = usrp_rate / audio_rate
            
        elif(options.to_file is not None):
            self.sink = blocks.file_sink(gr.sizeof_gr_complex, options.to_file)
            rrate = 1
        else:
            self.sink = blocks.null_sink(gr.sizeof_gr_complex)
            rrate = 1

        self.resampler = filter.pfb.arb_resampler_ccf(rrate)
            
	self.connect(self.audio_rx)
	self.connect(self.txpath, self.resampler, self.sink)
Beispiel #5
0
    def __init__(self, modulator_class, options):
        gr.top_block.__init__(self)
        self.txpath = transmit_path(modulator_class, options)
        self.audio_rx = audio_rx(options.audio_input)

        if(options.tx_freq is not None):
            self.sink = uhd_transmitter(options.address, options.bitrate,
                                        options.samples_per_symbol,
                                        options.tx_freq, options.tx_gain,
                                        options.antenna, options.verbose)
            options.samples_per_symbol = self.sink._sps
            audio_rate = self.audio_rx.sample_rate
            usrp_rate = self.sink.get_sample_rate()
            rrate = usrp_rate / audio_rate
            
        elif(options.to_file is not None):
            self.sink = blocks.file_sink(gr.sizeof_gr_complex, options.to_file)
            rrate = 1
        else:
            self.sink = blocks.null_sink(gr.sizeof_gr_complex)
            rrate = 1

        self.resampler = filter.pfb.arb_resampler_ccf(rrate)
            
	self.connect(self.audio_rx)
	self.connect(self.txpath, self.resampler, self.sink)
Beispiel #6
0
    def __init__(self, modulator,
                 options):  # Get options from call, modulator and options
        gr.top_block.__init__(self)

        if (options.tx_freq is not None):
            # Work-around to get the modulation's bits_per_symbol
            args = modulator.extract_kwargs_from_options(options)
            symbol_rate = options.bitrate / modulator(**args).bits_per_symbol()

            self.sink = uhd_transmitter(options.args, symbol_rate,
                                        options.samples_per_symbol,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
            options.samples_per_symbol = self.sink._sps

        elif (options.to_file is not None):
            sys.stderr.write(
                ("Saving samples to '%s'.\n\n" % (options.to_file)))
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            sys.stderr.write(
                "No sink defined, dumping samples to null sink.\n\n")
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
# Pass options to transmitter, setup transmitter, pass to pointer self.txpath
        self.txpath = transmit_path(modulator, options)

        # Connect and construct flowgraph
        self.connect(
            self.txpath,
            self.sink)  #--> back to main, to enable realtime scheduling
Beispiel #7
0
    def __init__(self, mod_class, demod_class,
                 rx_callback, options):

        gr.top_block.__init__(self)

        # Get the modulation's bits_per_symbol
        args = mod_class.extract_kwargs_from_options(options)
        symbol_rate = options.bitrate / mod_class(**args).bits_per_symbol()

        self.source = uhd_receiver(options.args, symbol_rate,
                                   options.samples_per_symbol,
                                   options.rx_freq, options.rx_gain,
                                   options.spec, options.antenna,
                                   options.verbose)
        
        self.sink = uhd_transmitter(options.args, symbol_rate,
                                    options.samples_per_symbol,
                                    options.tx_freq, options.tx_gain,
                                    options.spec, options.antenna,
                                    options.verbose)
        
        options.samples_per_symbol = self.source._sps

        self.txpath = transmit_path(mod_class, options)
        self.rxpath = receive_path(demod_class, rx_callback, options)
        self.connect(self.txpath, self.sink)
        self.connect(self.source, self.rxpath)
Beispiel #8
0
    def __init__(self, options, options_vr1, options_vr2):
        gr.top_block.__init__(self)

        if (options.file_sink is False):
            print("Using USRP")
            self.sink = uhd_transmitter(options.args, options.bandwidth,
                                        options.tx_freq, options.lo_offset,
                                        options.tx_gain, options.spec,
                                        options.antenna, options.clock_source,
                                        options.verbose)
        else:
            self.sink = blocks.null_sink(gr.sizeof_gr_complex)

        vr_configs = []
        vr_configs.append([options_vr1.freq, options_vr1.bandwidth])
        vr_configs.append([options_vr2.freq, options_vr2.bandwidth])
        hydra_sink = hydra.hydra_sink(2, options.fft_length,
                                      int(options.tx_freq),
                                      int(options.bandwidth), vr_configs)

        self.vr1_source = zeromq.pull_source(gr.sizeof_gr_complex, 1,
                                             'tcp://192.168.122.56:4000', 100,
                                             False, -1)
        self.vr2_source = zeromq.pull_source(gr.sizeof_gr_complex, 1,
                                             'tcp://192.168.122.208:4001', 100,
                                             False, -1)

        self.connect(self.vr1_source, (hydra_sink, 0), self.sink)
        self.connect(self.vr2_source, (hydra_sink, 1))
        self.hydra = hydra_sink

        self.xmlrpc_server = SimpleXMLRPCServer.SimpleXMLRPCServer(
            ("localhost", 12345), allow_none=True)
        self.xmlrpc_server.register_instance(self)
        threading.Thread(target=self.xmlrpc_server.serve_forever).start()
Beispiel #9
0
	def _setup_sink(self, options):
            self.symbol_rate=2; #for bpsk will edit the code later to set this automaticly based on the selected modulation scheme
	    self.sink = uhd_transmitter(options.args, self.symbol_rate,
                                        options.samples_per_symbol,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
Beispiel #10
0
    def __init__(self, modulator, options):
        gr.top_block.__init__(self)

        if(options.tx_freq is not None):
            # Work-around to get the modulation's bits_per_symbol
            args = modulator.extract_kwargs_from_options(options)
            symbol_rate = options.bitrate / modulator(**args).bits_per_symbol()

            self.sink = uhd_transmitter(options.args, symbol_rate,
                                        options.samples_per_symbol,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
            options.samples_per_symbol = self.sink._sps
            
        elif(options.to_file is not None):
            sys.stderr.write(("Saving samples to '%s'.\n\n" % (options.to_file)))
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            sys.stderr.write("No sink defined, dumping samples to null sink.\n\n")
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(modulator, options)

        self.connect(self.txpath, self.sink)
Beispiel #11
0
    def __init__(self, mod_class, demod_class, rx_callback, options):

        gr.top_block.__init__(self)

        # Get the modulation's bits_per_symbol
        args = mod_class.extract_kwargs_from_options(options)
        symbol_rate = options.bitrate / mod_class(**args).bits_per_symbol()

        self.source = uhd_receiver(options.args, symbol_rate,
                                   options.samples_per_symbol, options.rx_freq,
                                   options.rx_gain, options.spec,
                                   options.antenna, options.verbose)

        self.sink = uhd_transmitter(options.args, symbol_rate,
                                    options.samples_per_symbol,
                                    options.tx_freq, options.tx_gain,
                                    options.spec, options.antenna,
                                    options.verbose)

        options.samples_per_symbol = self.source._sps

        self.txpath = transmit_path(mod_class, options)
        self.rxpath = receive_path(demod_class, rx_callback, options)
        self.connect(self.txpath, self.sink)
        self.connect(self.source, self.rxpath)
Beispiel #12
0
    def __init__(self, callback, options):
        gr.top_block.__init__(self)

        if(options.tx_freq is not None): 
            self.sink = uhd_transmitter(options.args,
                                       options.bandwidth, options.tx_freq, 
                                       options.lo_offset, options.tx_gain,
                                       options.spec, options.antenna,
                                       options.clock_source, options.verbose)
#        elif(options.to_file is not None):
#            self.sink = blocks.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = blocks.null_sink(gr.sizeof_gr_complex)

        if(options.rx_freq is not None):
            self.source = uhd_receiver(options.args,
                                       options.bandwidth, options.rx_freq, 
                                       options.lo_offset, options.rx_gain,
                                       options.spec, options.antenna,
                                       options.clock_source, options.verbose)
#        elif(options.from_file is not None):
#            self.source = blocks.file_source(gr.sizeof_gr_complex, options.from_file)
        else:
            self.source = blocks.null_source(gr.sizeof_gr_complex)


        # Set up receive path
        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.rxpath = receive_path(callback, options)
        self.txpath = transmit_path(options)

        self.connect(self.source, self.rxpath)
        self.connect(self.txpath, self.sink)
    def __init__(self, modulator, options):
        gr.top_block.__init__(self)

        if (options.tx_freq is not None):
            # Work-around to get the modulation's bits_per_symbol
            args = modulator.extract_kwargs_from_options(options)
            symbol_rate = options.bitrate / modulator(**args).bits_per_symbol()

            self.sink = uhd_transmitter(options.args, symbol_rate,
                                        options.samples_per_symbol,
                                        options.tx_freq, options.lo_offset,
                                        options.tx_gain, options.spec,
                                        options.antenna, options.clock_source,
                                        options.verbose)
            options.samples_per_symbol = self.sink._sps

        elif (options.to_file is not None):
            sys.stderr.write(
                ("Saving samples to '%s'.\n\n" % (options.to_file)))
            self.sink = blocks.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            sys.stderr.write(
                "No sink defined, dumping samples to null sink.\n\n")
            self.sink = blocks.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(modulator, options)

        self.connect(self.txpath, self.sink)
Beispiel #14
0
    def __init__(self, mod, options):
        gr.top_block.__init__(self, "tx_mpsk")

        self._modulator_class = mod

        # Get mod_kwargs
        mod_kwargs = self._modulator_class.extract_kwargs_from_options(options)

        # transmitter
        self._modulator = self._modulator_class(**mod_kwargs)

        if (options.tx_freq is not None):
            symbol_rate = options.bitrate / self._modulator.bits_per_symbol()
            self._sink = uhd_transmitter(options.args, symbol_rate,
                                         options.samples_per_symbol,
                                         options.tx_freq, options.tx_gain,
                                         options.spec, options.antenna,
                                         options.verbose)
            options.samples_per_symbol = self._sink._sps

        elif (options.to_file is not None):
            self._sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self._sink = gr.null_sink(gr.sizeof_gr_complex)

        self._transmitter = bert_transmit(self._modulator._constellation,
                                          options.samples_per_symbol,
                                          options.differential,
                                          options.excess_bw,
                                          gray_coded=True,
                                          verbose=options.verbose,
                                          log=options.log)

        self.amp = gr.multiply_const_cc(options.amplitude)
        self.connect(self._transmitter, self.amp, self._sink)
Beispiel #15
0
    def __init__(self, options, payload=''):
        gr.top_block.__init__(self)

        if (options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args, options.bandwidth,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
        elif (options.to_file is not None):
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        options.interp = 100e6 / options.bandwidth  # FTW-specific convertion

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        if (options.from_file is None):
            self.txpath = ftw_transmit_path(options, payload)
        else:
            self.txpath = gr.file_source(gr.sizeof_gr_complex,
                                         options.from_file)
#            options.tx_amplitude = 1

# static value to make sure we do not exceed +-1 for the floats being sent to the sink
        self._tx_amplitude = options.tx_amplitude
        self.amp = gr.multiply_const_cc(self._tx_amplitude)

        # self.txpath = ftw_pnc_transmit_path(options, payload)
        self.connect(self.txpath, self.amp, self.sink)

        if options.log:
            self.connect(
                self.txpath,
                gr.file_sink(gr.sizeof_gr_complex, 'ftw_benchmark.dat'))
Beispiel #16
0
    def __init__(self, callback, options):
        gr.top_block.__init__(self)

        if (options.rx_freq is not None):
            self.source = uhd_receiver(options.args, options.bandwidth,
                                       options.rx_freq, options.rx_gain,
                                       options.spec, options.antenna,
                                       options.verbose)
        elif (options.from_file is not None):
            self.source = gr.file_source(gr.sizeof_gr_complex,
                                         options.from_file)
        else:
            self.source = gr.null_source(gr.sizeof_gr_complex)

        # Set up receive path
        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        if (options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args, options.bandwidth,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
        elif (options.to_file is not None):
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)
        self.source.set_sample_rate(1500000)  #rx sample rate
        self.sink.set_sample_rate(640000)
        self.rxpath = receive_path(callback, options)
        self.txpath = transmit_path(options)
        self.connect(self.source, self.rxpath)
        self.connect(self.txpath, self.sink)
        self.source.set_antenna("RX2")
        global freq
        freq = options.tx_freq  # - 12e6
    def __init__(self, options):
        gr.top_block.__init__(self)

        if options.outfile is not None:
            u = gr.file_sink(gr.sizeof_gr_complex, options.outfile)
        elif (options.tx_freq is not None) or (options.channel is not None):
            if options.channel is not None:
                self.chan_num = options.channel
                options.tx_freq = ieee802_15_4_pkt.chan_802_15_4.chan_map[
                    self.chan_num]

            u = uhd_transmitter(options.tx_args, options.bandwidth,
                                options.tx_freq, options.tx_gain, options.spec,
                                options.antenna, options.verbose,
                                options.external)
        else:
            raise SystemExit(
                "--tx-freq, --channel or --outfile must be specified\n")

        self.samples_per_symbol = 2

        # transmitter
        self.packet_transmitter = ieee802_15_4_pkt.ieee802_15_4_mod_pkts(
            self, spb=self.samples_per_symbol, msgq_limit=2, log=options.log)
        self.amp = gr.multiply_const_cc(1)

        self.u = u
        self.connect(self.packet_transmitter, self.amp, self.u)

        self.connect(self.amp,
                     gr.file_sink(gr.sizeof_gr_complex, 'cc2420-tx-diag.dat'))
    def __init__(self, modulator, demodulator, rx_callback, options):
        gr.top_block.__init__(self)
		#parameters to sense channe
        #options.symbol_rate=2500000
        #options.samples_per_symbol=2
        #options.rx_freq=2500000000
        #options.rx_gain=20
        #options.chbw_factor=1
        sense_symbol_rate=2500000
        sense_samples_per_symbol=2
        sense_rx_freq=2500000000
        sense_rx_gain=20
        options.chbw_factor=1
	#options.samples_per_symbol,

 
        #args = demodulator.extract_kwargs_from_options(options)
        self.sensesource=uhd_receiver(options.args, sense_symbol_rate,
                                       sense_samples_per_symbol,
                                       sense_rx_freq, sense_rx_gain,
                                       options.spec, options.antenna,
                                       options.verbose)

        if(options.tx_freq is not None):
            # Work-around to get the modulation's bits_per_symbol
            args = modulator.extract_kwargs_from_options(options)
            symbol_rate = options.bitrate / modulator(**args).bits_per_symbol()

            self.sink = uhd_transmitter(options.args, symbol_rate,
                                        options.samples_per_symbol,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
            options.samples_per_symbol = self.sink._sps
            
        elif(options.to_file is not None):
            sys.stderr.write(("Saving samples to '%s'.\n\n" % (options.to_file)))
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            sys.stderr.write("No sink defined, dumping samples to null sink.\n\n")
            self.sink = gr.null_sink(gr.sizeof_gr_complex)


        self.txgate = gr.copy(gr.sizeof_gr_complex)
        self.sensegate = gr.copy(gr.sizeof_gr_complex)
        #self.msgq             = gr.msg_queue()

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(modulator, options)

        self.connect(self.txpath, self.txgate, self.sink)

	# do sense
        self.sensepath = sensing_path(options)

        self.tx_enabled = True
	self.sense_flag=False
	self.connect(self.sensesource, self.sensepath)
Beispiel #19
0
    def __init__(self, callback, options):
        gr.top_block.__init__(self)

	### Rx Side ###

        if(options.rx_freq is not None):
            self.source = uhd_receiver(options.args_rx,
                                       options.bandwidth,
                                       options.rx_freq, options.rx_gain,
                                       options.spec, options.antenna,
                                       options.verbose)
        elif(options.from_file is not None):
            self.source = gr.file_source(gr.sizeof_gr_complex, options.from_file)
        else:
            self.source = gr.null_source(gr.sizeof_gr_complex)


        # Set up receive path
        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.rxpath = receive_path(callback, options)

        
	## Tx Side ###
	if(options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args_tx,
                                        options.bandwidth,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
        elif(options.to_file is not None):
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)


        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(options)
        self.connect(self.txpath, self.sink)

#        self.txpath = gr.message_source(gr.sizeof_gr_complex, 3)
#        nco_sensitivity = 2.0/options.fft_length   # correct for fine frequency
#        self.nco = ftw.pnc_frequency_modulator_fc(nco_sensitivity)
#        self.connect(self.txpath, self.sink) # self.nco, 

	# if you use two USRPs and want to synchonized
	# need to change uhd_interface.py
#	self.source.config_mimo()
#	time.sleep(1)	# to make sync stable

	if options.debug:
	    self.connect(self.source, gr.file_sink(gr.sizeof_gr_complex, 'rx.dat'))	# Save reception signal 
	else:
	    self.connect(self.source, self.rxpath)
            #self.connect(self.source, gr.file_sink(gr.sizeof_gr_complex, 'rx.dat'))

	if(options.verbose):
            self._print_verbage()
Beispiel #20
0
    def __init__(self, callback, options):
        gr.top_block.__init__(self)

        ### Rx Side ###

        if (options.rx_freq is not None):
            self.source = uhd_receiver(options.args_rx, options.bandwidth,
                                       options.rx_freq, options.rx_gain,
                                       options.spec, options.antenna,
                                       options.verbose)
        elif (options.from_file is not None):
            self.source = gr.file_source(gr.sizeof_gr_complex,
                                         options.from_file)
        else:
            self.source = gr.null_source(gr.sizeof_gr_complex)

        # Set up receive path
        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.rxpath = receive_path(callback, options)

        ## Tx Side ###
        if (options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args_tx, options.bandwidth,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
        elif (options.to_file is not None):
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(options)
        self.connect(self.txpath, self.sink)

        #        self.txpath = gr.message_source(gr.sizeof_gr_complex, 3)
        #        nco_sensitivity = 2.0/options.fft_length   # correct for fine frequency
        #        self.nco = ftw.pnc_frequency_modulator_fc(nco_sensitivity)
        #        self.connect(self.txpath, self.sink) # self.nco,

        # if you use two USRPs and want to synchonized
        # need to change uhd_interface.py
        #	self.source.config_mimo()
        #	time.sleep(1)	# to make sync stable

        if options.debug:
            self.connect(self.source,
                         gr.file_sink(gr.sizeof_gr_complex,
                                      'rx.dat'))  # Save reception signal
        else:
            self.connect(self.source, self.rxpath)
        #self.connect(self.source, gr.file_sink(gr.sizeof_gr_complex, 'rx.dat'))

        if (options.verbose):
            self._print_verbage()
Beispiel #21
0
 def __init__(self, options):
     gr.top_block.__init__(self)
     self.sink = uhd_transmitter(options.args, options.bandwidth,
                                 options.tx_freq, options.lo_offset,
                                 options.tx_gain, options.spec,
                                 options.antenna, options.clock_source,
                                 options.verbose)
     self.txpath = transmit_path(options)
     self.connect(self.txpath, self.sink)
Beispiel #22
0
 def __init__(self, options):
     gr.top_block.__init__(self)
     self.sink = uhd_transmitter(options.args,
                                 options.bandwidth, options.tx_freq,
                                 options.lo_offset, options.tx_gain,
                                 options.spec, options.antenna,
                                 options.clock_source, options.verbose)
     self.txpath = transmit_path(options)
     self.connect(self.txpath, self.sink)
Beispiel #23
0
    def __init__(self, rx_callback, options):
        gr.top_block.__init__(self)

        # Setting up 'Transmit Path'
        self.txpath = transmit_path(options, self)

        # Setting up 'Receive Path'
        packet = cnPacket()
        self.rxpath = receive_path(rx_callback, packet, options) 

        # Channel
        samples_per_packet = options.samples_per_symbol * 8 * 36
 
        if options.mode == 'default':
            print 'Operating mode : Default'
            
            mods = digital.modulation_utils.type_1_mods()
            modulator = mods[options.modulation]
            
            args = modulator.extract_kwargs_from_options(options)
            symbol_rate = options.bitrate / modulator(**args).bits_per_symbol()

            self.usrp_sink = uhd_transmitter(options.args, symbol_rate,
                                        options.samples_per_symbol,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)

            self.usrp_source = uhd_receiver(options.args, symbol_rate,
                                       options.samples_per_symbol,
                                       options.rx_freq, options.rx_gain,
                                       options.spec, options.antenna,
                                       options.verbose)

            options.samples_per_symbol = self.usrp_sink._sps
            
            
            #self.usrp_sink = usrp_sink(options)
            #self.usrp_source = usrp_source(options)
            self.connect(self.txpath, self.usrp_sink)
            self.connect(self.usrp_source, self.rxpath)

            
        elif options.mode == 'loopback':
            print 'Operating mode : Loopback'
      
            self.channel = channel_emulator(options,samples_per_packet)
            self.connect(self.txpath, self.channel, self.rxpath)
Beispiel #24
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        
        self.sink = uhd_transmitter(options.args,
                                    options.bandwidth,
                                    options.tx_freq, options.tx_gain,
                                    options.spec, options.antenna,
                                    options.verbose)
  

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(options)

        self.connect(self.txpath, self.sink)
Beispiel #25
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        if options.tx_freq is not None:
            u = uhd_transmitter(options.args, options.bandwidth,
                                options.tx_freq, options.tx_gain, options.spec,
                                options.antenna, options.external,
                                options.verbose)
        elif options.outfile is not None:
            u = gr.file_sink(gr.sizeof_gr_complex, options.outfile)
        else:
            raise SystemExit("--freq or --outfile must be specified\n")

        if options.infile is not None:
            tx = gr.file_source(gr.sizeof_gr_complex,
                                options.infile,
                                repeat=options.repeat)
        else:
            tx = ofdm_rxtx.TX(options)
            data_tones = tx.params.data_tones
            if options.char > 0:
                # read char from file
                data = gr.stream_to_vector(gr.sizeof_float, data_tones * 2)
                # NOTE: we use repeat, assuming the file is long enough or properly aligned
                self.connect(
                    gr.file_source(gr.sizeof_char, options.txdata,
                                   repeat=True), gr.char_to_float(),
                    gr.multiply_const_ff(options.char * (2**-0.5) / 128.0),
                    data)
            else:
                data = ofdm_rxtx.make_data(data_tones, options.size,
                                           options.txdata)
                if options.log:
                    self.connect(
                        data,
                        gr.file_sink(data_tones * gr.sizeof_gr_complex,
                                     'tx-data.dat'))

            self.connect(data, tx)
            self.sender = ofdm_rxtx.sender_thread(tx, options)

        if options.amp != 1:
            amp = gr.multiply_const_cc(options.amp)
            self.connect(tx, amp, u)
        else:
            self.connect(tx, u)
Beispiel #26
0
    def _setup_usrp_source2(self, options):
        """
        Creates a USRP sink, determines the settings for best bitrate,
        and attaches to the transmitter's subdevice.
        """
        print "setup_usrp_source2", self._tx_freq

        if (self._tx_freq is not None):
            self.u_sink = uhd_transmitter(options.args, options.bandwidth,
                                          self._tx_freq, options.tx_gain,
                                          options.spec, options.antenna,
                                          options.verbose)
        print "setup usrp sink ", self.u_sink
        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(options)
        self.connect(self.txpath, self.u_sink)
    def __init__(self, modulator, options):
        gr.top_block.__init__(self)

        if(options.tx_freq is not None):
            # Work-around to get the modulation's bits_per_symbol
            args = modulator.extract_kwargs_from_options(options)
            symbol_rate = options.bitrate / modulator(**args).bits_per_symbol()

            self.sink = uhd_transmitter(options.args, symbol_rate,
                                        options.samples_per_symbol, options.tx_freq,
                                        options.lo_offset, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.clock_source, options.verbose)
            options.samples_per_symbol = self.sink._sps
            
        elif(options.to_file is not None):
            sys.stderr.write(("Saving samples to '%s'.\n\n" % (options.to_file)))
            self.sink = blocks.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            sys.stderr.write("No sink defined, dumping samples to null sink.\n\n")
            self.sink = blocks.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(modulator, options)
        
        alpha = 0.001  
        thresh = 20  
        self.probe = analog.probe_avg_mag_sqrd_c(thresh,alpha)   
 
        self.source = uhd.usrp_source(  
            ",".join(("", "")),
            uhd.stream_args(
            cpu_format="fc32",
            channels=range(1),
            ),
	)
	self.source.set_samp_rate(self.sink._rate)  
	self.source.set_center_freq(uhd.tune_request(options.tx_freq,0))  
	self.source.set_gain(options.tx_gain)  
   
        self.connect(self.source, self.probe)       

	self.connect(self.txpath, self.sink)
        print >> sys.stderr, options
Beispiel #28
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        if (options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args, options.bandwidth,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
        elif (options.to_file is not None):
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = gr.file_source(gr.sizeof_gr_complex, options.data_file)
        self.amp = gr.multiply_const_cc(options.amp)
        self.connect(self.txpath, self.amp, self.sink)
Beispiel #29
0
    def _setup_usrp_source2(self,options):
        """
        Creates a USRP sink, determines the settings for best bitrate,
        and attaches to the transmitter's subdevice.
        """
        print "setup_usrp_source2",self._tx_freq

        if(self._tx_freq is not None):
            self.u_sink = uhd_transmitter(options.args,
                                        options.bandwidth,
                                        self._tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
        print "setup usrp sink " , self.u_sink
        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(options)
        self.connect(self.txpath, self.u_sink)
Beispiel #30
0
    def __init__(self, callback, fwd_callback, options):
        gr.top_block.__init__(self)

        self.source = uhd_receiver(options.args, options.bandwidth,
                                   options.rx_freq, options.rx_gain,
                                   options.spec, options.antenna,
                                   options.verbose)

        self.sink = uhd_transmitter(options.args, options.bandwidth,
                                    options.tx_freq, options.tx_gain,
                                    options.spec, options.antenna,
                                    options.verbose)

        self.rxpath = receive_path(callback, fwd_callback, options)
        self.connect(self.source, self.rxpath)

        self.txpath = transmit_path(options)
        self.connect(self.txpath, self.sink)
Beispiel #31
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        if(options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args,
                                        options.bandwidth,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
        elif(options.to_file is not None):
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = gr.message_source(gr.sizeof_gr_complex, 3)
        self.amp = gr.multiply_const_cc(options.amp)
        self.connect(self.txpath, self.amp, self.sink)
Beispiel #32
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        data_capsule = ( (+0+0j), (+0+0j), (+0+0j), (+0+0j), (+0+0j),
                         (+1+1j), (+1+1j), (+1+1j), (+1+1j), (+1+1j) )

        symbol_rate = 500000

        self.source = uhd_receiver(options.args, symbol_rate,
                                   2,
                                   options.rx_freq, 30,
                                   options.spec, "RX2",
                                   options.verbose)

        self.tx = uhd_transmitter(options.args, symbol_rate,
                                    2,
                                    options.tx_freq, 30,
                                    options.spec, "TX/RX", 
                                    options.verbose)

        options.samples_per_symbol = self.source._sps

        # Set up receive path
        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
 
        self.serve = gr.vector_source_c(data_capsule)
        
        #self.correlator = correlator_cc.correlator_cc()

        #self.sink = gr.vector_sink_c()
        #self.file_sink = gr.file_sink(gr.sizeof_gr_complex, "out")

        self.server = correlator_cc.go_start_cc()
        self.inserter = correlator_cc.preamble_insert_cc()
        self.correlator = correlator_cc.correlator_cc()
      
        self.connect(self.source, self.correlator)
        self.connect(self.serve, (self.server,0))
        self.connect(self.correlator, (self.server,1))
       
        self.connect(self.server, self.inserter)
        self.connect(self.inserter, self.tx)
Beispiel #33
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        if(options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args,
                                        options.bandwidth, options.tx_freq, 
                                        options.lo_offset, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.clock_source, options.verbose)
        elif(options.to_file is not None):
            self.sink = blocks.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = blocks.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(options)

        self.connect(self.txpath, self.sink)
    def __init__(self, options):
        gr.top_block.__init__(self)
        if options.freq is not None:
            u = uhd_transmitter(options.tx_args, options.bandwidth,
                                options.tx_freq, options.tx_gain, options.spec,
                                options.antenna, options.verbose,
                                options.external)
        elif options.outfile is not None:
            u = blocks.file_sink(gr.sizeof_gr_complex, options.outfile)
        else:
            raise SystemExit("--freq or --outfile must be specified\n")

        tx = transmit_path.ofdm_transmit_path(options)
        amp = blocks.multiply_const_cc(options.tx_amplitude)

        self.connect(tx, amp, u)

        self.tx = tx
        self.u = u
        self.outfile = options.outfile
Beispiel #35
0
    def __init__(self, callback, fwd_callback, options):
    #def __init__(self, options):
        gr.top_block.__init__(self)

        if(options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args,
                                        options.bandwidth,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)

	if(options.rx_freq is not None):
            self.source = uhd_receiver(options.args,
                                       options.bandwidth,
                                       options.rx_freq, options.rx_gain,
                                       options.spec, options.antenna,
                                       options.verbose)

        elif(options.to_file is not None):
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        print "flow:: ", options.flow

        # only for bidirectional flows: source in the reverse direction needs to 
        # start the ofdm_sink first to allow the socket connections working fine.. 
        if (options.flow == 1):
            self.rxpath = receive_path(callback, fwd_callback, options)
            self.connect(self.source, self.rxpath)

            self.txpath = transmit_path(options)
            self.connect(self.txpath, self.sink)
        else:
            self.txpath = transmit_path(options)
            self.connect(self.txpath, self.sink)

            self.rxpath = receive_path(callback, fwd_callback, options)
            self.connect(self.source, self.rxpath)
Beispiel #36
0
 def __init__(self, modulator_class, options):
     '''
     See below for what options should hold
     '''
     gr.hier_block2.__init__(self, "usrp_transmit_path",
             gr.io_signature(0, 0, 0),                    # Input signature
             gr.io_signature(0, 0, 0)) # Output signature
     tx_path = transmit_path.transmit_path(modulator_class, options)
     for attr in dir(tx_path): #forward the methods
         if not attr.startswith('_') and not hasattr(self, attr):
             setattr(self, attr, getattr(tx_path, attr))
     #setup usrp
     args = modulator_class.extract_kwargs_from_options(options)
     symbol_rate = options.bitrate / modulator_class(**args).bits_per_symbol()        
     self.sink = uhd_transmitter(options.args, symbol_rate,
         options.samples_per_symbol,
         options.tx_freq, options.tx_gain,
         options.spec, options.antenna,
         options.verbose)
     #connect
     self.connect(tx_path, self.sink)
Beispiel #37
0
  def __init__(self, options):
    gr.top_block.__init__(self)

    if options.tx_freq is not None:
      u = uhd_transmitter(options.args,
                          options.bandwidth,
                          options.tx_freq, options.tx_gain,
                          options.spec, options.antenna,
                          options.external, options.verbose)
    elif options.outfile is not None:
      u = gr.file_sink(gr.sizeof_gr_complex, options.outfile)
    else:
      raise SystemExit("--freq or --outfile must be specified\n")

    if options.infile is not None:
      tx = gr.file_source(gr.sizeof_gr_complex, options.infile, repeat = options.repeat)
    else:
      tx = ofdm_rxtx.TX(options)
      data_tones = tx.params.data_tones
      if options.char > 0:
        # read char from file
        data = gr.stream_to_vector(gr.sizeof_float, data_tones * 2)
        # NOTE: we use repeat, assuming the file is long enough or properly aligned
        self.connect(gr.file_source(gr.sizeof_char, options.txdata, repeat=True),
                     gr.char_to_float(),
                     gr.multiply_const_ff(options.char * (2**-0.5) / 128.0),
                     data)
      else:
        data = ofdm_rxtx.make_data(data_tones, options.size, options.txdata)
        if options.log:
          self.connect(data, gr.file_sink(data_tones * gr.sizeof_gr_complex, 'tx-data.dat'))

      self.connect(data, tx)
      self.sender = ofdm_rxtx.sender_thread(tx, options)

    if options.amp != 1:
      amp = gr.multiply_const_cc(options.amp)
      self.connect(tx, amp, u)
    else:
      self.connect(tx, u)
Beispiel #38
0
    def __init__(self, mod, options):
        gr.top_block.__init__(self, "tx_mpsk")

        self._modulator_class = mod

        # Get mod_kwargs
        mod_kwargs = self._modulator_class.extract_kwargs_from_options(options)

        # transmitter
        self._modulator = self._modulator_class(**mod_kwargs)

        if options.tx_freq is not None:
            self._sink = uhd_transmitter(
                options.args,
                options.bitrate,
                options.samples_per_symbol,
                options.tx_freq,
                options.tx_gain,
                options.antenna,
                options.verbose,
            )
            options.samples_per_symbol = self._sink._sps

        elif options.to_file is not None:
            self._sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self._sink = gr.null_sink(gr.sizeof_gr_complex)

        self._transmitter = bert_transmit(
            self._modulator._constellation,
            options.samples_per_symbol,
            options.differential,
            options.excess_bw,
            gray_coded=True,
            verbose=options.verbose,
            log=options.log,
        )

        self.connect(self._transmitter, self._sink)
Beispiel #39
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        # some arbitrary data
        data_capsule = ( (+1+1j), (+1+1j), (-1-1j), (-1-1j), (+1+1j),
                         (-1+1j), (-1+1j), (+1-1j), (+1-1j), (-1-1j) )


        # Work-around to get the modulation's bits_per_symbol
        symbol_rate = 500000

        self.sink = uhd_transmitter(options.args, symbol_rate,
                                    2,
                                    options.tx_freq, 30,
                                    options.spec, "TX/RX",
                                    options.verbose)

        self.rx = uhd_receiver(options.args, symbol_rate,
                               2, 
                               options.rx_freq, 30, 
                               options.spec, "RX2",
                               options.verbose)

        options.samples_per_symbol = self.sink._sps

        self.serve = gr.vector_source_c(data_capsule)
        #self.inserter = correlator_cc.preamble_insert_cc()
        #self.connect(self.source, self.inserter)
        #self.connect(self.inserter, self.sink)

        self.server = correlator_cc.go_start_cc()
        self.inserter = correlator_cc.preamble_insert_cc()
        self.correlator = correlator_cc.correlator_cc()

        self.connect(self.rx, self.correlator)
        self.connect(self.serve, (self.server,0))
        self.connect(self.correlator, (self.server,1))
        self.connect(self.server, self.inserter)
        self.connect(self.inserter, self.sink)
Beispiel #40
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        if (options.tx_freq is not None):
            options.bandwidth = 10000000 / 2
            #options.bandwidth = 100000000/16
            print options.bandwidth
            self.sink = uhd_transmitter(options.args, options.bandwidth,
                                        options.tx_freq, options.lo_offset,
                                        options.tx_gain, options.spec,
                                        options.antenna, options.clock_source,
                                        options.verbose)
        elif (options.to_file is not None):
            self.sink = blocks.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = blocks.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(options)

        self.connect(self.txpath, self.sink)
Beispiel #41
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        if(options.to_file is not None):
            self.file = blocks.file_sink(gr.sizeof_gr_complex, options.to_file)
            self.sink = blocks.throttle(gr.sizeof_gr_complex,1e6)
            self.connect( self.sink, self.file )
        elif(options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args,
                                        options.bandwidth, options.tx_freq, 
                                        options.lo_offset, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.clock_source, options.verbose)
        else:
            self.sink = blocks.null_sink(gr.sizeof_gr_complex)



        self._setup_tx_path(options)
        self._setup_rpc_manager()

        if options.freqoff is not None:
            freq_off = self.freq_off = channel.freq_offset(options.freqoff )
            self.connect(self.txpath, freq_off)
            self.txpath = freq_off
            self.rpc_mgr_tx.add_interface("set_freq_offset",self.freq_off.set_freqoff)

        if options.multipath:
          if options.itu_channel:
            self.fad_chan = channel.itpp_channel(options.bandwidth)
            self.rpc_mgr_tx.add_interface("set_channel_profile",self.fad_chan.set_channel_profile)
          else:
            self.fad_chan = filter.fir_filter_ccc(1,[1.0,0.0,2e-1+0.1j,1e-4-0.04j])

          self.connect(self.txpath, self.fad_chan)
          self.txpath = self.fad_chan


        self.connect(self.txpath, self.sink)
Beispiel #42
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        if (options.to_file is not None):
            self.file = blocks.file_sink(gr.sizeof_gr_complex, options.to_file)
            self.sink = blocks.throttle(gr.sizeof_gr_complex, 1e6)
            self.connect(self.sink, self.file)
        elif (options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args, options.bandwidth,
                                        options.tx_freq, options.lo_offset,
                                        options.tx_gain, options.spec,
                                        options.antenna, options.clock_source,
                                        options.verbose)
        else:
            self.sink = blocks.null_sink(gr.sizeof_gr_complex)

        self._setup_tx_path(options)
        self._setup_rpc_manager()

        if options.freqoff is not None:
            freq_off = self.freq_off = channel.freq_offset(options.freqoff)
            self.connect(self.txpath, freq_off)
            self.txpath = freq_off
            self.rpc_mgr_tx.add_interface("set_freq_offset",
                                          self.freq_off.set_freqoff)

        if options.multipath:
            if options.itu_channel:
                self.fad_chan = channel.itpp_channel(options.bandwidth)
                self.rpc_mgr_tx.add_interface(
                    "set_channel_profile", self.fad_chan.set_channel_profile)
            else:
                self.fad_chan = filter.fir_filter_ccc(
                    1, [1.0, 0.0, 2e-1 + 0.1j, 1e-4 - 0.04j])

            self.connect(self.txpath, self.fad_chan)
            self.txpath = self.fad_chan

        self.connect(self.txpath, self.sink)
Beispiel #43
0
    def __init__(self, byte_size, bit_rate=100000):
        gr.top_block.__init__(self)

        self.mod_type = "bpsk"  # bpsk or qpsk
        if (self.mod_type == "bpsk"):
            self.bits = 1
        else:
            self.bits = 2
        self.samples_per_symbol = 4
        self.bit_rate = bit_rate
        self.symbol_rate = self.bit_rate / self.bits
        self.freq = 1000000000.0

        self.trans = transmit_path(byte_size, self.mod_type,
                                   self.samples_per_symbol)
        self.sink = uhd_transmitter(sym_rate=self.symbol_rate,
                                    sps=self.samples_per_symbol,
                                    freq=self.freq,
                                    verbose=True,
                                    gain=19.5)

        self.connect(self.trans, self.sink)
    def __init__(self, callback, fwd_callback, options):
        #def __init__(self, options):
        gr.top_block.__init__(self)

        if (options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args, options.bandwidth,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)

        if (options.rx_freq is not None):
            self.source = uhd_receiver(options.args, options.bandwidth,
                                       options.rx_freq, options.rx_gain,
                                       options.spec, options.antenna,
                                       options.verbose)

        elif (options.to_file is not None):
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        print "flow:: ", options.flow

        # only for bidirectional flows: source in the reverse direction needs to
        # start the ofdm_sink first to allow the socket connections working fine..
        if (options.flow == 1):
            self.rxpath = receive_path(callback, fwd_callback, options)
            self.connect(self.source, self.rxpath)

            self.txpath = transmit_path(options)
            self.connect(self.txpath, self.sink)
        else:
            self.txpath = transmit_path(options)
            self.connect(self.txpath, self.sink)

            self.rxpath = receive_path(callback, fwd_callback, options)
            self.connect(self.source, self.rxpath)
Beispiel #45
0
    def __init__(self, callback, options):
        gr.top_block.__init__(self)
#rec
        if(options.rx_freq is not None):
            self.source = uhd_receiver(options.args,
                                       options.bandwidth,
                                       options.rx_freq, options.rx_gain,
                                       options.spec, options.antenna,
                                       options.verbose)
        elif(options.from_file is not None):
            self.source = gr.file_source(gr.sizeof_gr_complex, options.from_file)
        else:
            self.source = gr.null_source(gr.sizeof_gr_complex)

        # Set up receive path
        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.rxpath = receive_path(callback, options)

        self.connect(self.source, self.rxpath)
#trans
        if(options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args,
                                        options.bandwidth,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
        elif(options.to_file is not None):
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = transmit_path(options)

        self.connect(self.txpath, self.sink)
Beispiel #46
0
    def __init__(self, options):
        gr.top_block.__init__(self)
        use_sink = None
        if(options.tx_freq is not None):
            self.sink = uhd_transmitter(options.args,
                                        options.bandwidth,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
            use_sink = self.sink
        elif(options.to_file is not None):
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
            self.throttle = gr.throttle(gr.sizeof_gr_complex*1, options.file_samp_rate)
            self.connect(self.throttle, self.sink)
            use_sink = self.throttle
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath = [ ]
        self.txpath.append(transmit_path(options))
        self.txpath.append(transmit_path(options))

        samp_rate = 0
        if(options.tx_freq is not None):
            samp_rate = self.sink.get_sample_rate()
        else:
            samp_rate = options.file_samp_rate

        print "SAMP RATE " + str(samp_rate)    

        volume = options.split_amplitude
        band_transition = options.band_trans_width
        low_transition = options.low_trans_width
        guard_width = options.guard_width

        self.low_pass_filter_qv0 = gr.interp_fir_filter_ccf(2, firdes.low_pass(
            1, samp_rate, samp_rate/4-guard_width/2, low_transition, firdes.WIN_HAMMING, 6.76))
        self.freq_translate_qv0 = filter.freq_xlating_fir_filter_ccc(1, (options.num_taps, ), samp_rate/4, samp_rate)
        self.band_pass_filter_qv0 = gr.fir_filter_ccc(1, firdes.complex_band_pass(
            1, samp_rate, -samp_rate/2+guard_width, 0-guard_width, band_transition, firdes.WIN_HAMMING, 6.76))

        self.low_pass_filter_qv1 = gr.interp_fir_filter_ccf(2, firdes.low_pass(
            1, samp_rate, samp_rate/4-guard_width/2, low_transition, firdes.WIN_HAMMING, 6.76))
        self.freq_translate_qv1 = filter.freq_xlating_fir_filter_ccc(1, (options.num_taps, ), -samp_rate/4, samp_rate)
        self.band_pass_filter_qv1 = gr.fir_filter_ccc(1, firdes.complex_band_pass(
            1, samp_rate, 0+guard_width, samp_rate/2-guard_width, band_transition, firdes.WIN_HAMMING, 6.76))

        self.combiner = gr.add_vcc(1)
        self.volume_multiply = blocks.multiply_const_vcc((volume, ))

        self.connect((self.txpath[0], 0), (self.low_pass_filter_qv0, 0))
        self.connect((self.txpath[1], 0), (self.low_pass_filter_qv1, 0))

        self.connect((self.low_pass_filter_qv0, 0), (self.freq_translate_qv0, 0))
        self.connect((self.freq_translate_qv0, 0), (self.band_pass_filter_qv0, 0))

        self.connect((self.low_pass_filter_qv1, 0), (self.freq_translate_qv1, 0))
        self.connect((self.freq_translate_qv1, 0), (self.band_pass_filter_qv1, 0))

        self.connect((self.band_pass_filter_qv0, 0), (self.combiner, 0))
        self.connect((self.band_pass_filter_qv1, 0), (self.combiner, 1))

        self.connect((self.combiner, 0), (self.volume_multiply, 0))

        self.connect(self.volume_multiply, use_sink)
Beispiel #47
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        # Input Data File
        TX_input_file = "TX_Input_Data"
        _TX_input_file = "TX_Input_Data"
        # TX_input_file = "Ding_Dong2.wma"
        # _TX_input_file = 'Ding_Dong2.wma'
        TX_source_data = gr.file_source(gr.sizeof_char, TX_input_file)
        TX_Input_filesize = os.stat(_TX_input_file).st_size

        # RX_output_file = "RX_output_test_file"
        # _RX_output_file = 'RX_output_test_file'

        # RX_file_sink = gr.file_sink(gr.sizeof_char, RX_output_file)
        # RX_output_filesize = os.stat(_RX_output_file).st_size

        # Source block
        # frame = ((+1+0j),(+1+0j),(+1+0j),(+1+0j),(+1+0j),(+1+0j),(+1+0j),(+1+0j),(+1+0j),(+1+0j))

        zeros10 = (0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
        zeros20 = zeros10 + zeros10
        zeros40 = zeros20 + zeros20

        frame_pad223 = zeros40 + zeros40 + zeros40 + zeros40 + zeros40 + zeros20 + (0x0, 0x0, 0x0)
        frame_pad219 = (
            zeros40 + zeros40 + zeros40 + zeros40 + zeros40 + zeros10 + (0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
        )
        frame_pad215 = zeros40 + zeros40 + zeros40 + zeros40 + zeros40 + zeros10 + (0x0, 0x0, 0x0, 0x0, 0x0)
        frame_pad183 = zeros40 + zeros40 + zeros40 + zeros40 + zeros20 + (0x0, 0x0, 0x0)
        frame_pad179 = zeros40 + zeros40 + zeros40 + zeros40 + zeros10 + (0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)

        data12 = (0xD, 0xE, 0xA, 0xD, 0xB, 0xE, 0xE, 0xF, 0xD, 0x0, 0x0, 0xD)
        data40 = data12 + data12 + data12 + (0xD, 0xE, 0xA, 0xD)
        data10 = (0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9)

        data223 = data40 + data40 + data40 + data40 + data40 + data10 + data10 + (0xA, 0xB, 0xC)
        data219 = data40 + data40 + data40 + data40 + data40 + data10 + (0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8)
        data183 = data40 + data40 + data40 + data40 + data10 + data10 + (0x0, 0x1, 0x2)

        # src = frame_pad + data + data + data + data + frame_pad
        # src = frame_pad + frame_pad + data + data + data + data + data + data + data + data + data + data+ data + frame_pad + frame_pad

        # src = frame_pad215+data219+frame_pad219

        # 10 frames
        # src = frame_pad215+frame_pad219+data219+data219+data219+data219+data219+data219+frame_pad219+frame_pad219

        # 20 frames
        # src = frame_pad215+frame_pad219+data219+data219+data219+data219+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+frame_pad219+frame_pad219

        # 8 frames
        # src = frame_pad215+frame_pad219+data219+data219+data219+data219+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+data219+data219
        # src = src+frame_pad219+frame_pad219
        # 50 frames

        # 8 frames
        src = frame_pad179 + frame_pad183 + data183 + data183 + data183 + data183 + data183 + data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        # src = src+data183+data183
        src = src + frame_pad183 + frame_pad183
        # 50 frames

        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src

        # print len(src)
        # print len(data)

        # data = data + data + data + data

        # data = data + data + data + data + data + data + data + data + data + data + data + data + data + data
        # data = (0xd, 0xe, 0xa, 0xd, 0xb, 0xe, 0xe, 0xf, 0xd, 0x0)
        # self.source = gr.vector_source_b(src)
        # self.source = gr.vector_source_b(frame_pad)

        # CRC TX block
        # self.crctx = crc.crctx()

        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src

        # print len(src)
        # print len(data)

        # data = data + data + data + data

        # data = data + data + data + data + data + data + data + data + data + data + data + data + data + data
        # data = (0xd, 0xe, 0xa, 0xd, 0xb, 0xe, 0xe, 0xf, 0xd, 0x0)
        # self.source = gr.vector_source_b(src)
        # self.source = gr.vector_source_b(frame_pad)

        # CRC TX block
        # self.crctx = crc.crctx()
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src
        # src = src + src

        # print len(src)
        # print len(data)

        # data = data + data + data + data

        # data = data + data + data + data + data + data + data + data + data + data + data + data + data + data
        # data = (0xd, 0xe, 0xa, 0xd, 0xb, 0xe, 0xe, 0xf, 0xd, 0x0)
        # self.source = gr.vector_source_b(src)
        # self.source = gr.vector_source_b(frame_pad)

        # CRC TX block
        self.crctx = crc.crctx(TX_Input_filesize)

        # RS encoding
        self.encoder = rscoding_bb.encode_bb()

        # Spreader
        self.spreader = spreader.spreader_bc()

        # Preamble insert block
        self.inserter = correlator_cc.preamble_insert_cc()

        # Printer block
        self.printer = print_bb.print_bb()

        # Sink block
        symbol_rate = 500000  # Work-around to get the modulation's bits_per_symbol
        self.sink = uhd_transmitter(options.args, symbol_rate, 2, options.tx_freq, 30, options.spec, "TX/RX", 1)
        # options.verbose)
        options.samples_per_symbol = self.sink._sps

        ntaps = 11 * int(options.samples_per_symbol)
        self.rrc_taps = gr.firdes.root_raised_cosine(1.0, 1000000, symbol_rate, 1.0, ntaps)
        self.rrc_filter = gr.interp_fir_filter_ccf(1, self.rrc_taps)

        # Connect the blocks
        # self.connect(self.source, self.inserter)
        # self.connect(self.inserter, self.sink)
        # self.connect(self.source, self.spreader)
        self.connect(TX_source_data, self.crctx)
        # self.connect(self.crctx, self.printer)
        # self.connect(self.printer, self.encoder)
        self.connect(self.crctx, self.encoder)
        self.connect(self.encoder, self.spreader)
        # self.connect(self.source, self.spreader)
        self.connect(self.spreader, self.inserter)
        # self.connect(self.inserter, self.rrc_filter)
        # self.connect(self.rrc_filter, self.sink)
        self.connect(self.inserter, self.sink)
def main():
    #Searches for static 1Mhz windows	
    def find_hole(power_list):
	bin_start=0
	bin_stop=0
	bins=0
	results = []
	for i in range(0,len(power_list)):
		if power_list[i]< 40.0 :
			bins=bins+1
			if bins == 34:
				bin_stop=i
				break
		else:
			bins=0
			bin_start=i+1
	if bin_stop == 0:
		return 0
	results.append(bin_start)
	results.append(bin_stop)
	return results
    #Attemp to find where opponent transmits
    def fuzz_target(power_list):
	bin_start=0
        bin_stop=0
        for i in range(0,len(power_list)):
                if power_list[i] > 60.0 :
                        bin_start = i
			if (i+34) <= len(power_list):
                        	bin_stop = i+34
                        else:
				bin_stop = len(power_list)
			break
   
        if bin_start == 0:
                return 0
        middle_bin = ((bin_stop-bin_start)/2) + bin_start
	result = (middle_bin*27902) + 2357500000.0 
        return result
	


    def send_pkt(payload='', eof=False):
        return tb.txpath.send_pkt(payload, eof)

    mods = digital.modulation_utils.type_1_mods()
    
    parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
    expert_grp = parser.add_option_group("Expert")

    parser.add_option("-m", "--modulation", type="choice", choices=mods.keys(),
                      default='qpsk',
                      help="Select modulation from: %s [default=%%default]"
                            % (', '.join(mods.keys()),))

    parser.add_option("-s", "--size", type="eng_float", default=1500,
                      help="set packet size [default=%default]")
    parser.add_option("-M", "--megabytes", type="eng_float", default=1.0,
                      help="set megabytes to transmit [default=%default]")
    parser.add_option("","--discontinuous", action="store_true", default=False,
                      help="enable discontinous transmission (bursts of 5 packets)")
    parser.add_option("","--from-file", default=None,
                      help="use intput file for packet contents")
    parser.add_option("","--to-file", default=None,
                      help="Output file for modulated samples")
    parser.add_option("","--server", action="store_true", default=False,
                      help="To take data from the server")

    transmit_path.add_options(parser, expert_grp)
    uhd_transmitter.add_options(parser)

    for mod in mods.values():
        mod.add_options(expert_grp)

    (options, args) = parser.parse_args ()

    if len(args) != 0:
        parser.print_help()
        sys.exit(1)
           
    if options.from_file is not None:
        source_file = open(options.from_file, 'r')

    # build the graph
   # tb = my_top_block(mods[options.modulation], options)

    r = gr.enable_realtime_scheduling()
    if r != gr.RT_OK:
        print "Warning: failed to enable realtime scheduling"
    
    sb = senseblock()
    freq_list = []
    packet_list = []
   
    #Initialise
    tb = my_top_block(mods[options.modulation], options)
    tb.start()                       # start flow graph


#Fake tranmission phase, to provoke opponent attacks
    payload_fake = struct.pack('!H', 666 & 0xffff) + "Qamazing team, if we lose handshake freq we are done for!"    
    for i in range(0, 4000):
    	send_pkt(payload_fake)
	sys.stderr.write('.')

#Sense and fuzz phase
    tb.lock()
    time.sleep(2)
    sb.start()
    freq_list = sense_loop(sb)
    for i in range(0,1000):
        fuzz_result = fuzz_target(freq_list)
    print "Sensing complete, stoping senseblock, prepare to fuzz"
    sb.stop()
    sb.wait()
    tb.unlock()
    if fuzz_result != 0:
    	options.tx_freq= fuzz_result
    	sink = uhd_transmitter(options.args, symbol_rate2,
                                        options.samples_per_symbol, options.tx_freq,
                                        options.lo_offset, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.clock_source, options.verbose)
    	txpath = transmit_path(modulator2, options)
    	for i in range(0, 4000):
       		send_pkt(payload_fake)
        	sys.stderr.write('.')
    else:
	time.sleep(1)
	print "Did not find fuzz targets"
    time.sleep(2)
    print "Fuzzing phase complete"	
    
    

#Initial sense and then send the result at handshake freq
    tb.lock()
    sb.start()
    freq_list = sense_loop(sb)
    while True :
    	bin_results = find_hole(freq_list)
        if bin_results != 0 :
        	break;
    middle_bin = int(((bin_results[1]-bin_results[0])/2) + bin_results[0])
    print "Sensing complete, stoping senseblock preparation"
    sb.stop()
    sb.wait()
    tb.unlock()
    #Jump to handshake freq
    options.tx_freq=2362000000
    sink = uhd_transmitter(options.args, symbol_rate2,
                                        options.samples_per_symbol, options.tx_freq,
                                        options.lo_offset, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.clock_source, options.verbose)
    txpath = transmit_path(modulator2, options)

    #Special pktno to distinguish sensing packets
    number = 3333
    #Set new transmit freq to midpoint of discovered window
    new_freq = str((middle_bin*27902) + 2357500000.0)
    payload_sense = struct.pack('!H', number & 0xffff) + new_freq
    #Send a large number of sensing packets (may change if ACK is developed), and then jump
    #to new freq
    for i in range(0, 2000):
    	send_pkt(payload_sense)
    time.sleep(1)
    options.tx_freq=(middle_bin*27902) + 2357500000.0
    sink = uhd_transmitter(options.args, symbol_rate2,
                                        options.samples_per_symbol, options.tx_freq,
                                        options.lo_offset, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.clock_source, options.verbose)
    txpath = transmit_path(modulator2, options)

#Main transmit phase 
    # generate and send packets
    nbytes = int(1e6 * options.megabytes)
    n = 0
    pktno = 0
    pkt_size = int(options.size)
    
    # connect to server
    if options.server:
    	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	server_address = ('10.0.0.200', 50000)
    	print >>sys.stderr, 'connecting to %s port %s' % server_address
    	sock.connect(server_address)


    while pktno <= 1000 and options.server:
	#print "nbytes :%s , pkt_size : %s , n : %s " %(nbytes, pkt_size, n)
        if options.server:
            data = "";
            while len(data) < pkt_size:
                data += sock.recv(pkt_size - len(data))
                if data == '':
                    # No more data received from server
                    sock.close()
                    break;
        elif options.from_file is None:
            data = (pkt_size - 2) * chr(pktno & 0xff)
        else:
            data = source_file.read(pkt_size - 2)
	pktno+=1
	packet_list.append(data)
    #Send packets in bursts of 100 or 165 and then sense again
    #Repeat process, until end of expirement
    loop_check = True
    while(1):
	for i in range(0, len(packet_list)):
		data=packet_list[i]
        	payload = struct.pack('!H', i & 0xffff) + data
        	send_pkt(payload)
        	sys.stderr.write('.')
        	#Alternate 2 loops, so that the system jumps at different packet numbers
		#This is to ensure, we dont lose packets due to transmitter jumping slightly faster
        	if i % 100 == 0 and i > 0 and loop_check:
			tb.lock()
    			    	
        		sb.start()
        		freq_list = sense_loop(sb)
			while True :
                		bin_results = find_hole(freq_list)
                		if bin_results != 0 :
                        		break;

        		middle_bin = int(((bin_results[1]-bin_results[0])/2) + bin_results[0])		
    			print "Sensing complete, stoping senseblock main"
			sb.stop()
			sb.wait()
			tb.unlock()
		        number = 3333
	        	new_freq = str((middle_bin*27902) + 2357500000.0)
       	        	payload_sense = struct.pack('!H', number & 0xffff) + new_freq

			for i in range(0, 2000):
				send_pkt(payload_sense)
			time.sleep(1)
			options.tx_freq=(middle_bin*27902) + 2357500000.0
        		sink = uhd_transmitter(options.args, symbol_rate2,
                                        options.samples_per_symbol, options.tx_freq,
                                        options.lo_offset, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.clock_source, options.verbose)
        		txpath = transmit_path(modulator2, options)
		elif i % 165 == 0 and i > 0 and not loop_check:
                        tb.lock()

                        sb.start()
                        freq_list = sense_loop(sb)
                        while True :
                                bin_results = find_hole(freq_list)
                                if bin_results != 0 :
                                        break;

                        middle_bin = int(((bin_results[1]-bin_results[0])/2) + bin_results[0])
                        print "Sensing complete, stoping senseblock main"
                        sb.stop()
                        sb.wait()
                        tb.unlock()
                        number = 3333
                        new_freq = str((middle_bin*27902) + 2357500000.0)
                        payload_sense = struct.pack('!H', number & 0xffff) + new_freq

                        for i in range(0, 2000):
                                send_pkt(payload_sense)
                        time.sleep(1)
                        options.tx_freq=(middle_bin*27902) + 2357500000.0
                        sink = uhd_transmitter(options.args, symbol_rate2,
                                        options.samples_per_symbol, options.tx_freq,
                                        options.lo_offset, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.clock_source, options.verbose)
                        txpath = transmit_path(modulator2, options)
	loop_check = not(loop_check)
        
    send_pkt(eof=True)

    tb.wait()                       # wait for it to finish
Beispiel #49
0
    def __init__(self, mod, options):
        gr.top_block.__init__(self, "tx_mpsk")
        Qt.QWidget.__init__(self)
        self.setWindowTitle("MPSK Tx")

        try:
            self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
        except:
            pass
        self.top_scroll_layout = Qt.QVBoxLayout()
        self.setLayout(self.top_scroll_layout)
        self.top_scroll = Qt.QScrollArea()
        self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
        self.top_scroll_layout.addWidget(self.top_scroll)
        self.top_scroll.setWidgetResizable(True)
        self.top_widget = Qt.QWidget()
        self.top_scroll.setWidget(self.top_widget)
        self.top_layout = Qt.QVBoxLayout(self.top_widget)
        self.top_grid_layout = Qt.QGridLayout()
        self.top_layout.addLayout(self.top_grid_layout)

        self._modulator_class = mod

        # Get mod_kwargs
        mod_kwargs = self._modulator_class.extract_kwargs_from_options(options)

        # transmitter
        self._modulator = self._modulator_class(**mod_kwargs)

        if (options.tx_freq is not None):
            symbol_rate = options.bitrate / self._modulator.bits_per_symbol()
            self._sink = uhd_transmitter(options.args, symbol_rate,
                                         options.samples_per_symbol,
                                         options.tx_freq, options.tx_gain,
                                         options.spec, options.antenna,
                                         options.verbose)
            options.samples_per_symbol = self._sink._sps

        elif (options.to_file is not None):
            self._sink = blocks.file_sink(gr.sizeof_gr_complex,
                                          options.to_file)
        else:
            self._sink = blocks.null_sink(gr.sizeof_gr_complex)

    #Create GUI to see symbols constellation
        self.qtgui_const_sink = qtgui.const_sink_c(
            400,  #size
            "",  #name
            1  #number of inputs
        )
        self.qtgui_const_sink.set_update_time(0.1)
        self.qtgui_const_sink.set_y_axis(-2, 2)
        self.qtgui_const_sink.set_x_axis(-2, 2)
        self.qtgui_const_sink.set_trigger_mode(qtgui.TRIG_MODE_FREE,
                                               qtgui.TRIG_SLOPE_POS, 0.0, 0,
                                               "")
        self.qtgui_const_sink.enable_autoscale(False)
        self.qtgui_const_sink.enable_grid(False)
        self.qtgui_const_sink.enable_axis_labels(True)

        if not True:
            self.qtgui_const_sink.disable_legend()

        labels = ["", "", "", "", "", "", "", "", "", ""]
        widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
        colors = [
            "blue", "red", "red", "red", "red", "red", "red", "red", "red",
            "red"
        ]
        styles = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        markers = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
        for i in xrange(1):
            if len(labels[i]) == 0:
                self.qtgui_const_sink.set_line_label(i, "Data {0}".format(i))
            else:
                self.qtgui_const_sink.set_line_label(i, labels[i])
            self.qtgui_const_sink.set_line_width(i, widths[i])
            self.qtgui_const_sink.set_line_color(i, colors[i])
            self.qtgui_const_sink.set_line_style(i, styles[i])
            self.qtgui_const_sink.set_line_marker(i, markers[i])
            self.qtgui_const_sink.set_line_alpha(i, alphas[i])

        self._qtgui_const_sink_win = sip.wrapinstance(
            self.qtgui_const_sink.pyqwidget(), Qt.QWidget)
        self.top_layout.addWidget(self._qtgui_const_sink_win)

        self._transmitter = bert_transmit(self._modulator._constellation,
                                          options.samples_per_symbol,
                                          options.differential,
                                          options.excess_bw,
                                          gray_coded=True,
                                          verbose=options.verbose,
                                          log=options.log)

        self.amp = blocks.multiply_const_cc(options.amplitude)

        self.connect(self._transmitter, self.amp, self._sink)

        self.connect(self.amp, self.qtgui_const_sink)
    def __init__(self, modulator, demodulator, rx_callback, options):
        gr.top_block.__init__(self)

        sense_symbol_rate=2500000
        sense_samples_per_symbol=2
        sense_rx_freq=2500000000
        sense_rx_gain=20
        options.chbw_factor=1
   
        global bandchoose


 
        #args = demodulator.extract_kwargs_from_options(options)
        self.sensesource=uhd_receiver(options.args, sense_symbol_rate,
                                       sense_samples_per_symbol,
                                       sense_rx_freq, sense_rx_gain,
                                       options.spec, options.antenna,
                                       options.verbose)

        if(options.tx_freq is not None):
            # Work-around to get the modulation's bits_per_symbol
            args = modulator.extract_kwargs_from_options(options)
            symbol_rate = options.bitrate / modulator(**args).bits_per_symbol()
	    
            fa = samp_rate/4 #1000000

            self.sink = uhd_transmitter(options.args, symbol_rate,
                                        options.samples_per_symbol,
                                        options.tx_freq, options.tx_gain,
                                        options.spec, options.antenna,
                                        options.verbose)
            options.samples_per_symbol = self.sink._sps
            
        elif(options.to_file is not None):
            sys.stderr.write(("Saving samples to '%s'.\n\n" % (options.to_file)))
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            sys.stderr.write("No sink defined, dumping samples to null sink.\n\n")
            self.sink = gr.null_sink(gr.sizeof_gr_complex)


        self.txgate = gr.copy(gr.sizeof_gr_complex)
        self.sensegate = gr.copy(gr.sizeof_gr_complex)
        #self.msgq             = gr.msg_queue()

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)


	# do sense
        self.sensepath = sensing_path(options)

        self.tx_enabled = True
	self.sense_flag=False

        self.connect(self.sensesource, self.sensepath)

	# do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath1 = transmit_path(modulator, options)
	self.txpath2 = transmit_path(modulator, options)

	#self.connect(self.txpath, self.sink)

	# Define the math operator blocks
	

	# Generate exp(jw1t) and exp(-jw1t)
	self.gr_multiply_xx_0 = gr.multiply_vff(1)
	self.gr_float_to_complex_0_0 = gr.float_to_complex(1)
	self.gr_float_to_complex_0 = gr.float_to_complex(1)
	self.const_source_x_0 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, -1)
	self.analog_sig_source_x_0_0 = gr.sig_source_f(samp_rate, gr.GR_SIN_WAVE, fa, 1, 0)
	self.analog_sig_source_x_0 = gr.sig_source_f(samp_rate, gr.GR_COS_WAVE, fa, 1, 0)


	# Combine signal from two subbands
	self.gr_multiply_xx_1 = gr.multiply_vcc(1)
	self.gr_multiply_xx_2 = gr.multiply_vcc(1)
	self.gr_c2f_1 = gr.complex_to_float(1)
	self.gr_c2f_2 = gr.complex_to_float(1)
	self.gr_add_xx_re = gr.add_vff(1)
	self.gr_add_xx_im = gr.add_vff(1)
	self.gr_f2c = gr.float_to_complex(1)
	
 	self.gr_null_source_0 = gr.null_source(gr.sizeof_gr_complex*1)

	# output from gr_float_to_complex_0_0 is exp(-jw1t)
	# output from gr_float_to_complex_0 is exp(jw1t)
	self.connect((self.gr_multiply_xx_0, 0), (self.gr_float_to_complex_0_0, 1))
	self.connect((self.analog_sig_source_x_0, 0), (self.gr_float_to_complex_0_0, 0))
	self.connect((self.analog_sig_source_x_0_0, 0), (self.gr_float_to_complex_0, 1))
	self.connect((self.analog_sig_source_x_0, 0), (self.gr_float_to_complex_0, 0))
	self.connect((self.analog_sig_source_x_0_0, 0), (self.gr_multiply_xx_0, 0))
	self.connect((self.const_source_x_0, 0), (self.gr_multiply_xx_0, 1)) 

	# txpath1 * exp(-jw1t)
	#self.connect(self.txpath1, (self.gr_multiply_xx_1, 0))
	self.connect((self.gr_float_to_complex_0_0, 0), (self.gr_multiply_xx_1, 1))
	# txpath2 * exp(jw1t)
	#self.connect(self.txpath2, (self.gr_multiply_xx_2, 0))
	
	self.connect((self.gr_float_to_complex_0, 0), (self.gr_multiply_xx_2, 1))
	
	if bandchoose == 0:
		self.connect(self.txpath1, (self.gr_multiply_xx_1, 0))
		self.connect(self.gr_null_source_0 , (self.gr_multiply_xx_2, 0))
	elif bandchoose == 1:
		self.connect(self.gr_null_source_0 , (self.gr_multiply_xx_1, 0))
		self.connect(self.txpath2, (self.gr_multiply_xx_2, 0))
	else:
		self.connect(self.txpath1, (self.gr_multiply_xx_1, 0))
		self.connect(self.txpath2, (self.gr_multiply_xx_2, 0))

	self.connect((self.gr_multiply_xx_1, 0), self.gr_c2f_1)
	self.connect((self.gr_multiply_xx_2, 0), self.gr_c2f_2)

	self.connect((self.gr_c2f_1,0), (self.gr_add_xx_re,0))
	self.connect((self.gr_c2f_2,0), (self.gr_add_xx_re,1))

	self.connect((self.gr_c2f_1,1), (self.gr_add_xx_im,0))
	self.connect((self.gr_c2f_2,1), (self.gr_add_xx_im,1))

	self.connect(self.gr_add_xx_re, (self.gr_f2c,0))
	self.connect(self.gr_add_xx_im, (self.gr_f2c,1))
        self.connect(self.gr_f2c, self.sink)
Beispiel #51
0
    def __init__(self, modulator, options):
        gr.top_block.__init__(self)

        self.txpath = []
        use_sink = None
        if options.tx_freq is not None:
            # Work-around to get the modulation's bits_per_symbol
            args = modulator.extract_kwargs_from_options(options)
            symbol_rate = options.bitrate / modulator(**args).bits_per_symbol()

            self.sink = uhd_transmitter(
                options.args,
                symbol_rate,
                options.samples_per_symbol,
                options.tx_freq,
                options.tx_gain,
                options.spec,
                options.antenna,
                options.verbose,
            )
            sample_rate = self.sink.get_sample_rate()
            options.samples_per_symbol = self.sink._sps
            use_sink = self.sink
        elif options.to_file is not None:
            sys.stderr.write(("Saving samples to '%s'.\n\n" % (options.to_file)))
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
            self.throttle = gr.throttle(gr.sizeof_gr_complex * 1, options.file_samp_rate)
            self.connect(self.throttle, self.sink)
            use_sink = self.throttle
        else:
            sys.stderr.write("No sink defined, dumping samples to null sink.\n\n")
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        # do this after for any adjustments to the options that may
        # occur in the sinks (specifically the UHD sink)
        self.txpath.append(transmit_path(modulator, options))
        self.txpath.append(transmit_path(modulator, options))

        samp_rate = 0
        if options.tx_freq is not None:
            samp_rate = self.sink.get_sample_rate()
        else:
            samp_rate = options.file_samp_rate

        volume = options.split_amplitude
        band_transition = options.band_trans_width
        low_transition = options.low_trans_width
        guard_width = options.guard_width

        self.low_pass_filter_qv0 = gr.interp_fir_filter_ccf(
            2, firdes.low_pass(1, samp_rate, samp_rate / 4 - guard_width / 2, low_transition, firdes.WIN_HAMMING, 6.76)
        )
        self.freq_translate_qv0 = filter.freq_xlating_fir_filter_ccc(1, (options.num_taps,), samp_rate / 4, samp_rate)
        self.band_pass_filter_qv0 = gr.fir_filter_ccc(
            1,
            firdes.complex_band_pass(
                1, samp_rate, -samp_rate / 2 + guard_width, 0 - guard_width, band_transition, firdes.WIN_HAMMING, 6.76
            ),
        )

        self.low_pass_filter_qv1 = gr.interp_fir_filter_ccf(
            2, firdes.low_pass(1, samp_rate, samp_rate / 4 - guard_width / 2, low_transition, firdes.WIN_HAMMING, 6.76)
        )
        self.freq_translate_qv1 = filter.freq_xlating_fir_filter_ccc(1, (options.num_taps,), -samp_rate / 4, samp_rate)
        self.band_pass_filter_qv1 = gr.fir_filter_ccc(
            1,
            firdes.complex_band_pass(
                1, samp_rate, 0 + guard_width, samp_rate / 2 - guard_width, band_transition, firdes.WIN_HAMMING, 6.76
            ),
        )

        self.combiner = gr.add_vcc(1)
        self.volume_multiply = blocks.multiply_const_vcc((volume,))

        self.connect((self.txpath[0], 0), (self.low_pass_filter_qv0, 0))
        self.connect((self.txpath[1], 0), (self.low_pass_filter_qv1, 0))

        self.connect((self.low_pass_filter_qv0, 0), (self.freq_translate_qv0, 0))
        self.connect((self.freq_translate_qv0, 0), (self.band_pass_filter_qv0, 0))

        self.connect((self.low_pass_filter_qv1, 0), (self.freq_translate_qv1, 0))
        self.connect((self.freq_translate_qv1, 0), (self.band_pass_filter_qv1, 0))

        self.connect((self.band_pass_filter_qv0, 0), (self.combiner, 0))
        self.connect((self.band_pass_filter_qv1, 0), (self.combiner, 1))

        self.connect((self.combiner, 0), (self.volume_multiply, 0))

        self.connect(self.volume_multiply, use_sink)
Beispiel #52
0
    def __init__(self, options):
        gr.top_block.__init__(self)

        if(options.tx_freq is not None):
            symbol_rate = 500000
	    self.sink = uhd_transmitter(options.args, symbol_rate,
					2,
					options.tx_freq, 30,
					options.spec, "TX/RX",
					1)
	    options.samples_per_symbol = self.sink._sps
        elif(options.to_file is not None):
            sys.stderr.write(("Saving samples to '%s'.\n\n" % (options.to_file)))
            self.sink = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
        else:
            sys.stderr.write("No sink defined, dumping samples to null sink.\n\n")
            self.sink = gr.null_sink(gr.sizeof_gr_complex)

        # Packetizer
	self.packettx = packetizer.packet_source()

        # CRC TX block
        self.crctx = crc.crctx(0)

        # RS encoding
        self.encoder = rscoding_bb.encode_bb()

        # Spreader
        self.spreader = spreader.spreader_bc()

	# Preamble insert block
        self.inserter = correlator_cc.preamble_insert_cc()

        # Printer block
        self.printer = print_bb.print_bb()

        ntaps = 11 * int(options.samples_per_symbol)
        self.rrc_taps = gr.firdes.root_raised_cosine( 
                      1.0,
                      1000000,
                      symbol_rate,
                      1.0,
                      ntaps)
        self.rrc_filter = gr.interp_fir_filter_ccf(1, self.rrc_taps)


	# Connect the blocks
        #self.connect(self.source, self.inserter)
        #self.connect(self.inserter, self.sink)
        #self.connect(self.source, self.spreader)
        #self.connect(TX_source_data, self.crctx)
        self.connect(self.packettx, self.crctx)
        #self.connect(self.crctx, self.printer)
        #self.connect(self.printer, self.encoder)
        self.connect(self.crctx, self.encoder)
        self.connect(self.encoder, self.spreader)
        #self.connect(self.source, self.spreader)
        self.connect(self.spreader, self.inserter)
        #self.connect(self.inserter, self.rrc_filter)
        #self.connect(self.rrc_filter, self.sink)
        self.connect(self.inserter, self.sink)
  def __init__(self, options_tx, options_rx, callback):
    gr.top_block.__init__(self)

    self.init_pctime = 0
    self.init_hwtime = 0

    self.tx_outfile    = options_tx.tx_outfile
    self._tx_amplitude = options_tx.tx_amplitude 
    #######################################################################
    #                              USRP Config                            #
    #######################################################################
    tx_slave=False
    rx_slave=False
    if options_tx.tx_args != options_rx.rx_args:
      print "===Transceiver: enable MIMO mode, RX as slave, TX as master==="
      rx_slave=True
    if options_rx.mode == "PNC":
      rx_slave=False
      
    # lzyou: it seems that you MUST put rx before tx
    # otherwise something strange will happen (eg, not synced even the program tells you synced)
    d_rx_enable = True
    if options_rx.rx_freq is not None:
      source = uhd_receiver(options_rx.rx_args,
                            options_rx.bandwidth,
                            options_rx.rx_freq, options_rx.rx_gain,
                            options_rx.spec, options_rx.antenna,
                            options_rx.verbose, options_rx.external, rx_slave)
      #source.u.set_min_output_buffer(163840)
    elif options_rx.rx_infile is not None:
      source = blocks.file_source(gr.sizeof_gr_complex, options_rx.rx_infile)
    else:
      source = None
      d_rx_enable = False
    self.d_rx_enable = d_rx_enable
    self.source = source
    
    d_tx_enable = True
    if options_tx.tx_freq is not None:
      sink = uhd_transmitter(options_tx.tx_args,
                             options_tx.bandwidth,
                             options_tx.tx_freq, options_tx.tx_gain,
                             options_tx.spec, options_tx.antenna,
                             options_tx.verbose, options_tx.external, tx_slave)
    elif options_tx.tx_outfile is not None:
      sink = blocks.file_sink(gr.sizeof_gr_complex, options_tx.tx_outfile)
    else:
      sink = None
      d_tx_enable = False
    self.d_tx_enable = d_tx_enable
    self.sink = sink
    #######################################################################

    # FIXME: support diff (tx/rx) framebytes   
    self.framebytes = None
    #######################################################################
    #                              Tx Path                                #
    #######################################################################
    if d_tx_enable:
      self.tx = transmit_path.ofdm_transmit_path(options_tx)
      self.amp = blocks.multiply_const_cc(self._tx_amplitude)
      #self.amp.set_min_output_buffer(163840)
      self.connect(self.tx, self.amp, self.sink)
      self.framebytes = self.tx.framebytes
    #######################################################################
    
    #######################################################################
    #                              Rx Path                                #
    #######################################################################
    # log usrp raw samples
    #if options_rx.mode == 'PNC':
    #  self.connect(source, blocks.file_sink(gr.sizeof_gr_complex, '/tmp/PNCRXdiag.dat'))
    if options_rx.logfile:
      if options_rx.mode == 'PNC':
        self.connect(source, blocks.file_sink(gr.sizeof_gr_complex, '/tmp/PNCRXdiag.dat'))
      else:
        assert(options_rx.node != None)

      if options_rx.node == 'A':
        self.connect(source, blocks.file_sink(gr.sizeof_gr_complex, '/tmp/NodeARXdiag.dat'))
      elif options_rx.node == 'B':
        self.connect(source, blocks.file_sink(gr.sizeof_gr_complex, '/tmp/NodeBRXdiag.dat'))

    # setup receive_path
    if d_rx_enable:
      if options_rx.rx_outfile is not None:
        self.rx = blocks.file_sink(gr.sizeof_gr_complex, options_rx.rx_outfile)
        self.connect(self.source, self.rx)
        return
      
      self.rx = receive_path.ofdm_receive_path(options_rx, callback)
      #if self.framebytes is not None:
      #  assert(self.framebytes == self.rx.framebytes)
      self.framebytes = self.rx.framebytes
      self.connect(self.source, self.rx)
    else:
      self.rx = None

    #######################################################################
    if options_rx.profile:
      from gnuradio.ctrlport import monitor
      self.ctrlport_monitor = monitor()
      self.ctrlport_monitor_performance = monitor("gr-perf-monitorx")