def __init__(self, options, rx_callback): phy_base.__init__(self, options, rx_callback) # Receive chain demod_class = phy_psk.DEMODS[options.psk_modulation] demod_kwargs = demod_class.extract_kwargs_from_options(options) self._rx_demod = blks2.demod_pkts( demod_class(**demod_kwargs), callback=self._rx_callback) sw_decim = 1 self._rx_chan_filt = gr.fft_filter_ccc( sw_decim, gr.firdes.low_pass ( 1.0, # gain sw_decim * self._rx_demod._demodulator.samples_per_symbol(), # sampling rate 1.0, # midpoint of trans. band 0.5, # width of trans. band gr.firdes.WIN_HANN)) # filter type self.connect(self, self._rx_chan_filt, self._rx_demod) # Trasmit chain mod_class = phy_psk.MODS[options.psk_modulation] mod_kwargs = mod_class.extract_kwargs_from_options(options) self._tx_mod = blks2.mod_pkts( mod_class(**mod_kwargs), pad_for_usrp=True) self.connect(self._tx_mod, gr.kludge_copy(gr.sizeof_gr_complex), self)
def __init__(self, outputfile, options): gr.top_block.__init__(self) if options.dsp: self.dst = audio.sink( options.dsp_sample_rate ) else: self.dst = gr.wavfile_sink(outputfile, 2, options.wav_sample_rate, 16) self.c_to_iq = gr.complex_to_float() self.connect( (self.c_to_iq, 0), (self.dst, 0)) self.connect( (self.c_to_iq, 1), (self.dst, 1)) # settings for the modulator: /usr/local/lib/python2.5/site-packages/gnuradio/blks2impl/gmsk.py self.modulator = blks2.gmsk_mod(samples_per_symbol=options.samples_per_symbol) self.pkt_queue = blks2.mod_pkts( modulator=self.modulator ) if options.carrier_frequency == 0: self.mixer = self.pkt_queue else: self.mixer = gr.multiply_vcc(1) self.carrier = gr.sig_source_c( options.carrier_sample_rate, gr.GR_SIN_WAVE, options.carrier_frequency, 1.0 ) self.lowpass = gr.fir_filter_ccf(1, firdes.low_pass(1, 48000, 48000/(2*options.samples_per_symbol)+500, 500, firdes.WIN_HAMMING, 6.76)) self.connect(self.pkt_queue, self.lowpass, (self.mixer, 0) ) self.connect(self.carrier, (self.mixer, 1) ) self.amp = gr.multiply_const_cc(1); self.amp.set_k(options.amp_amplitude) self.connect(self.mixer, self.amp, self.c_to_iq) if options.debug_wavs: from myblks import debugwav self._dpassw = debugwav("tx_passband", options) self._dprefw = debugwav("tx_prefband", options) self._dbasew = debugwav("tx_baseband", options) self.connect(self.amp, self._dpassw) self.connect(self.lowpass, self._dbasew) self.connect(self.pkt_queue, self._dprefw) if options.debug_files: self._dpassf = gr.file_sink(gr.sizeof_gr_complex*1, "debug_tx_passband.d_c") self._dpreff = gr.file_sink(gr.sizeof_gr_complex*1, "debug_tx_prefband.d_c") self._dbasef = gr.file_sink(gr.sizeof_gr_complex*1, "debug_tx_baseband.d_c") self.connect(self.amp, self._dpassf) self.connect(self.pkt_queue, self._dpreff) self.connect(self.lowpass, self._dbasef)
def __init__(self, modulator_class, options): ''' See below for what options should hold ''' gr.hier_block2.__init__( self, "transmit_path", gr.io_signature(0, 0, 0), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature options = copy.copy( options) # make a copy so we can destructively modify self._verbose = options.verbose self._tx_amplitude = options.tx_amplitude # digital amplitude sent to USRP self._bitrate = options.bitrate # desired bit rate self._samples_per_symbol = options.samples_per_symbol # desired samples/baud self._modulator_class = modulator_class # the modulator_class we are using # Get mod_kwargs mod_kwargs = self._modulator_class.extract_kwargs_from_options(options) # transmitter modulator = self._modulator_class(**mod_kwargs) self.packet_transmitter = \ blks2.mod_pkts(modulator, access_code=None, msgq_limit=4, pad_for_usrp=True) self.amp = gr.multiply_const_cc(1) self.set_tx_amplitude(self._tx_amplitude) # Display some information about the setup if self._verbose: self._print_verbage() # Connect components in the flowgraph self.connect(self.packet_transmitter, self.amp, self)
def __init__(self, modulator_class, options): ''' See below for what options should hold ''' gr.hier_block2.__init__(self, "transmit_path", gr.io_signature(0, 0, 0), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature options = copy.copy(options) # make a copy so we can destructively modify self._verbose = options.verbose self._tx_amplitude = options.tx_amplitude # digital amplitude sent to USRP self._bitrate = options.bitrate # desired bit rate self._samples_per_symbol = options.samples_per_symbol # desired samples/baud self._modulator_class = modulator_class # the modulator_class we are using # Get mod_kwargs mod_kwargs = self._modulator_class.extract_kwargs_from_options(options) # transmitter print self._modulator_class print mod_kwargs modulator = self._modulator_class(**mod_kwargs) self.packet_transmitter = \ blks2.mod_pkts(modulator, access_code=None, msgq_limit=4, pad_for_usrp=True) self.amp = gr.multiply_const_cc(1) self.set_tx_amplitude(self._tx_amplitude) # Display some information about the setup if self._verbose: self._print_verbage() # Connect components in the flowgraph self.connect(self.packet_transmitter, self.amp, self)
def __init__(self, modulator, demodulator, access_code=None, hint="addr=192.168.10.2"): gr.hier_block2.__init__(self, "Physical Layer", gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0)) if access_code is "master": self.rx_offset = 8e6 access_code = None elif access_code is "slave": self.rx_offset = -8e6 access_code = None else: self.rx_offset = 0 # create TX/RX self.u_tx = uhd.single_usrp_sink(hint, io_type=uhd.io_type_t.COMPLEX_FLOAT32, num_channels=1) self.u_rx = uhd.single_usrp_source(hint, io_type=uhd.io_type_t.COMPLEX_FLOAT32, num_channels=1) self.access_code = access_code # create packetmods self.pkt_mod = blks2.mod_pkts(modulator, pad_for_usrp=True, access_code=self.access_code) self.pkt_demod = blks2.demod_pkts(demodulator, callback=self.rx_callback, access_code=self.access_code) self.connect(self.u_rx, self.pkt_demod) self.connect(self.pkt_mod, self.u_tx)
def __init__(self, modulator_class, options): ''' See below for what options should hold ''' gr.hier_block2.__init__(self, "transmit_path", gr.io_signature(0, 0, 0), # Input signature gr.io_signature(0, 0, 0)) # Output signature options = copy.copy(options) # make a copy so we can destructively modify self._verbose = options.verbose self._tx_freq = options.tx_freq # tranmitter's center frequency self._tx_amplitude = options.tx_amplitude # digital amplitude sent to USRP self._tx_subdev_spec = options.tx_subdev_spec # daughterboard to use self._bitrate = options.bitrate # desired bit rate self._interp = options.interp # interpolating rate for the USRP (prelim) self._samples_per_symbol = options.samples_per_symbol # desired samples/baud self._fusb_block_size = options.fusb_block_size # usb info for USRP self._fusb_nblocks = options.fusb_nblocks # usb info for USRP self._use_whitener_offset = options.use_whitener_offset # increment start of whitener XOR data self._modulator_class = modulator_class # the modulator_class we are using if self._tx_freq is None: sys.stderr.write("-f FREQ or --freq FREQ or --tx-freq FREQ must be specified\n") raise SystemExit # Set up USRP sink; also adjusts interp, samples_per_symbol, and bitrate self._setup_usrp_sink() # copy the final answers back into options for use by modulator options.samples_per_symbol = self._samples_per_symbol options.bitrate = self._bitrate options.interp = self._interp # Get mod_kwargs mod_kwargs = self._modulator_class.extract_kwargs_from_options(options) # Set center frequency of USRP ok = self.set_freq(self._tx_freq) if not ok: print "Failed to set Tx frequency to %s" % (eng_notation.num_to_str(self._tx_freq),) raise ValueError # transmitter self.packet_transmitter = \ blks2.mod_pkts(self._modulator_class(**mod_kwargs), access_code=None, msgq_limit=4, pad_for_usrp=True, use_whitener_offset=options.use_whitener_offset) # Set the USRP for maximum transmit gain # (Note that on the RFX cards this is a nop.) self.set_gain(self.subdev.gain_range()[1]) self.amp = gr.multiply_const_cc(1) self.set_tx_amplitude(self._tx_amplitude) # enable Auto Transmit/Receive switching self.set_auto_tr(True) # Display some information about the setup if self._verbose: self._print_verbage() # Create and setup transmit path flow graph self.connect(self.packet_transmitter, self.amp, self.u)