示例#1
0
 def test_008_connect_invalid_dst_port_exceeds(self):
     hblock = gr.hier_block2(
         "test_block", gr.io_signature(1, 1, gr.sizeof_int), gr.io_signature(1, 1, gr.sizeof_int)
     )
     nop1 = gr.null_sink(gr.sizeof_int)
     nop2 = gr.null_sink(gr.sizeof_int)
     self.assertRaises(ValueError, lambda: hblock.connect(nop1, (nop2, 1)))
示例#2
0
 def test_008_connect_invalid_dst_port_exceeds(self):
     hblock = gr.hier_block2("test_block",
                             gr.io_signature(1, 1, gr.sizeof_int),
                             gr.io_signature(1, 1, gr.sizeof_int))
     nop1 = gr.null_sink(gr.sizeof_int)
     nop2 = gr.null_sink(gr.sizeof_int)
     self.assertRaises(ValueError, lambda: hblock.connect(nop1, (nop2, 1)))
 def test_005_one_src_two_dst (self):
     fg = self.fg
     src1 = gr.null_source (gr.sizeof_int)
     dst1 = gr.null_sink (gr.sizeof_int)
     dst2 = gr.null_sink (gr.sizeof_int)
     fg.connect ((src1, 0), (dst1, 0))
     fg.connect ((src1, 0), (dst2, 0))
示例#4
0
 def xInit(self, signals, noises, sinks):
 #   ------------------------------------------------------------------------
     self.sources = {}
     self.mutes = {}
     self.amps = {}
     
     #sources
     for signal in signals:
         self.sources[signal] = gr.sig_source_f(
             self.samprate, gr.GR_SIN_WAVE, 440, 0.25, 0)
         self.mutes[signal] = gr.mute_ff(True)
         self.amps[signal] = gr.multiply_const_ff(0.25)
     for noise in noises:
         self.sources[noise] = analog.noise_source_f(
             analog.GR_LAPLACIAN, 1, 0)
         self.mutes[noise] = gr.mute_ff(True)
         self.amps[noise] = gr.multiply_const_ff(0.25)
     #mixer
     if len(self.sources) > 1:
         self.adder = self.add = gr.add_vff(1)
     else:
         self.adder = gr.multiply_const_vff((1, ))
     self.level = gr.multiply_const_ff(1)
     
     #sinks
     self.sinks = sinks
         
     self.audiomute = gr.mute_ff(True)
     self.audio = audio.sink(self.samprate, "", True)
     self.udp = gr.null_sink(gr.sizeof_float)
     self.rawfile = gr.null_sink(gr.sizeof_float)
     self.wavefile = gr.null_sink(gr.sizeof_float)
 def test_007_validate (self):
     fg = self.fg
     src1 = gr.null_source (gr.sizeof_int)
     dst1 = gr.null_sink (gr.sizeof_int)
     dst2 = gr.null_sink (gr.sizeof_int)
     fg.connect ((src1, 0), (dst1, 0))
     fg.connect ((src1, 0), (dst2, 0))
     fg.validate ()
示例#6
0
 def StopAllSinks(self):
 #   ------------------------------------------------------------------------
     self.audiomute.set_mute(True)
     self.Stop()
     self.udp = gr.null_sink(gr.sizeof_float)
     self.rawfile = gr.null_sink(gr.sizeof_float)
     self.wavefile = gr.null_sink(gr.sizeof_float)
     self.Start()
 def test_010_validate (self):
     fg = self.fg
     src1 = gr.null_source (gr.sizeof_int)
     nop1 = gr.nop (gr.sizeof_int)
     dst1 = gr.null_sink (gr.sizeof_int)
     dst2 = gr.null_sink (gr.sizeof_int)
     fg.connect ((src1, 0), (nop1, 0))
     fg.connect ((src1, 0), (nop1, 1))
     fg.connect ((nop1, 0), (dst1, 0))
     fg.connect ((nop1, 2), (dst2, 0))
     self.assertRaises (ValueError,
                        lambda : fg.validate ())
示例#8
0
 def xSetEnable(self, sender, state):
 #   ------------------------------------------------------------------------
     if sender == "Audio Out":
         self.audiomute.set_mute(not state)
         
     if sender == "UDP Out":
         host = self.udpconfig["host"]
         port = self.udpconfig["port"]
         self.Stop()
         if state == False or not host or not port:
             self.udp = gr.null_sink(gr.sizeof_float)
             wx.GetApp().PostStatus(
                 "SignalGenerator Info: Stopped UDP output to \"%s:%s\"" % (
                     host, port))
         else:
             self.udp = gr.udp_sink(gr.sizeof_float, host, port, 1472, True)
             wx.GetApp().PostStatus(
                 "SignalGenerator Info: Started UDP output to \"%s:%s\"" % (
                     host, port))
         self.Start()
         
     if sender == "File Out":
         filename = self.fileconfig["filename"]
         self.Stop()
         if state == False or not filename:
             self.rawfile = gr.null_sink(gr.sizeof_float)
             wx.GetApp().PostStatus(
                 "SignalGenerator Info: Stopped rawfile device \"%s\"" % (
                     filename,))
         else:
             self.rawfile = gr.file_sink(gr.sizeof_float, filename)
             wx.GetApp().PostStatus(
                 "SignalGenerator Info: Started rawfile device \"%s\"" % (
                     filename,))
         self.Start()
                 
     if sender == "Wave Out":
         filename = self.waveconfig["filename"]
         self.Stop()
         if state == False or not filename:
             self.wavefile = gr.null_sink(gr.sizeof_float)
             wx.GetApp().PostStatus(
                 "SignalGenerator Info: Stopped wave device \"%s\"" % (
                     filename,))
                     
         else:
             self.wavefile = gr.wavfile_sink(filename, 1, self.samprate, 16)
             wx.GetApp().PostStatus(
                 "SignalGenerator Info: Started wave device \"%s\"" % (
                     filename,))
         self.Start()
    def test01(self):
        sps = 4
        rolloff = 0.35
        bw = 2 * math.pi / 100.0
        ntaps = 45

        # Create pulse shape filter
        #rrc_taps = gr.firdes.root_raised_cosine(
        #    sps, sps, 1.0, rolloff, ntaps)
        rrc_taps = taps

        # The frequency offset to correct
        foffset = 0.2 / (2.0 * math.pi)

        # Create a set of 1's and -1's, pulse shape and interpolate to sps
        random.seed(0)
        data = [2.0 * random.randint(0, 2) - 1.0 for i in xrange(200)]
        self.src = gr.vector_source_c(data, False)
        self.rrc = gr.interp_fir_filter_ccf(sps, rrc_taps)

        # Mix symbols with a complex sinusoid to spin them
        self.nco = gr.sig_source_c(1, gr.GR_SIN_WAVE, foffset, 1)
        self.mix = gr.multiply_cc()

        # FLL will despin the symbols to an arbitrary phase
        self.fll = digital_swig.fll_band_edge_cc(sps, rolloff, ntaps, bw)

        # Create sinks for all outputs of the FLL
        # we will only care about the freq and error outputs
        self.vsnk_frq = gr.vector_sink_f()
        self.nsnk_fll = gr.null_sink(gr.sizeof_gr_complex)
        self.nsnk_phs = gr.null_sink(gr.sizeof_float)
        self.nsnk_err = gr.null_sink(gr.sizeof_float)

        # Connect the blocks
        self.tb.connect(self.nco, (self.mix, 1))
        self.tb.connect(self.src, self.rrc, (self.mix, 0))
        self.tb.connect(self.mix, self.fll, self.nsnk_fll)
        self.tb.connect((self.fll, 1), self.vsnk_frq)
        self.tb.connect((self.fll, 2), self.nsnk_phs)
        self.tb.connect((self.fll, 3), self.nsnk_err)
        self.tb.run()

        N = 700
        dst_data = self.vsnk_frq.data()[N:]

        expected_result = len(dst_data) * [
            -0.20,
        ]
        self.assertFloatTuplesAlmostEqual(expected_result, dst_data, 4)
    def test01 (self):
        sps = 4
        rolloff = 0.35
        bw = 2*math.pi/100.0
        ntaps = 45
        
        # Create pulse shape filter
        #rrc_taps = gr.firdes.root_raised_cosine(
        #    sps, sps, 1.0, rolloff, ntaps)
        rrc_taps = taps

        # The frequency offset to correct
        foffset = 0.2 / (2.0*math.pi)

        # Create a set of 1's and -1's, pulse shape and interpolate to sps
        random.seed(0)
        data = [2.0*random.randint(0, 2) - 1.0 for i in xrange(200)]
        self.src = gr.vector_source_c(data, False)
        self.rrc = gr.interp_fir_filter_ccf(sps, rrc_taps)

        # Mix symbols with a complex sinusoid to spin them
        self.nco = gr.sig_source_c(1, gr.GR_SIN_WAVE, foffset, 1)
        self.mix = gr.multiply_cc()

        # FLL will despin the symbols to an arbitrary phase
        self.fll = digital_swig.fll_band_edge_cc(sps, rolloff, ntaps, bw)

        # Create sinks for all outputs of the FLL
        # we will only care about the freq and error outputs
        self.vsnk_frq = gr.vector_sink_f()
        self.nsnk_fll = gr.null_sink(gr.sizeof_gr_complex)
        self.nsnk_phs = gr.null_sink(gr.sizeof_float)
        self.nsnk_err = gr.null_sink(gr.sizeof_float)
        
        # Connect the blocks
        self.tb.connect(self.nco, (self.mix,1))
        self.tb.connect(self.src, self.rrc, (self.mix,0))
        self.tb.connect(self.mix, self.fll, self.nsnk_fll)
        self.tb.connect((self.fll,1), self.vsnk_frq)
        self.tb.connect((self.fll,2), self.nsnk_phs)
        self.tb.connect((self.fll,3), self.nsnk_err)
        self.tb.run()
        
        N = 700
        dst_data = self.vsnk_frq.data()[N:]

        expected_result = len(dst_data)* [-0.20,]
        self.assertFloatTuplesAlmostEqual (expected_result, dst_data, 4)
示例#11
0
	def test_001_srcsink_ss (self):
		sys.stderr.write("Creating null source\n")
		src = gr.null_source(gr.sizeof_short)
		sys.stderr.write("Creating throttle\n")
		thr = gr.throttle(gr.sizeof_short,1000)
		sys.stderr.write("Creating fake SPI device\n")
		dummy = spi.srcsink_ss("/dev/null",1000000)
		sys.stderr.write("Creating null sink\n")
		sink = gr.null_sink(gr.sizeof_short)
		sys.stderr.write("Connecting source to throttle\n")
		self.fg.connect(src,thr)
		sys.stderr.write("Connecting throttle to SPI\n")
		self.fg.connect(thr,dummy)
		sys.stderr.write("Connecting SPI to sink\n")
		self.fg.connect(dummy,sink)
		sys.stderr.write("Starting flow graph\n")
		self.fg.start()
                time.sleep(0.1)
		sys.stderr.write("Stopping flow graph\n")
		self.fg.stop()
		sys.stderr.write("Deleting blocks\n")
		del src
		del thr
		del dummy
		del sink
		sys.stderr.write("All done!\n")
 def test_004_no_such_dst_port (self):
     fg = self.fg
     src1 = gr.null_source (gr.sizeof_int)
     dst1 = gr.null_sink (gr.sizeof_int)
     self.assertRaises (ValueError,
                        lambda : fg.connect ((src1, 0),
                                             (dst1, 1)))
 def test_014_connect_varargs (self):
     fg = self.fg
     src1 = gr.null_source (gr.sizeof_int)
     nop1 = gr.nop (gr.sizeof_int)
     dst1 = gr.null_sink (gr.sizeof_int)
     fg.connect (src1, nop1, dst1)
     fg.validate ()
示例#14
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 = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
            rrate = 1
        else:
            self.sink = gr.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)
 def test_101_tsort_two (self):
     fg = self.fg
     src1 = gr.null_source (gr.sizeof_int)
     dst1 = gr.null_sink (gr.sizeof_int)
     fg.connect ((src1, 0), (dst1, 0))
     fg.validate ()
     self.assertEqual ([src1, dst1], fg.topological_sort (fg.all_blocks ()))
示例#16
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)
示例#17
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 = gr.file_sink(gr.sizeof_gr_complex, options.to_file)
            rrate = 1
        else:
            self.sink = gr.null_sink(gr.sizeof_gr_complex)
            rrate = 1

        self.resampler = blks2.pfb_arb_resampler_ccf(rrate)

        self.connect(self.audio_rx)
        self.connect(self.txpath, self.resampler, self.sink)
示例#18
0
    def __init__(self,
                 N,
                 op,
                 isizeof=gr.sizeof_gr_complex,
                 osizeof=gr.sizeof_gr_complex,
                 nsrcs=1,
                 nsnks=1):
        gr.top_block.__init__(self, "helper")

        self.op = op
        self.srcs = []
        self.snks = []
        self.head = gr.head(isizeof, N)

        for n in xrange(nsrcs):
            self.srcs.append(gr.null_source(isizeof))

        for n in xrange(nsnks):
            self.snks.append(gr.null_sink(osizeof))

        self.connect(self.srcs[0], self.head, (self.op, 0))

        for n in xrange(1, nsrcs):
            self.connect(self.srcs[n], (self.op, n))

        for n in xrange(nsnks):
            self.connect((self.op, n), self.snks[n])
 def test_107 (self):
     fg = self.fg
     src1 = gr.null_source (gr.sizeof_int)
     src2 = gr.null_source (gr.sizeof_int)
     nop1 = gr.nop (gr.sizeof_int)
     nop2 = gr.nop (gr.sizeof_int)
     dst1 = gr.null_sink (gr.sizeof_int)
     dst2 = gr.null_sink (gr.sizeof_int)
     
     fg.connect (src1, nop1)
     fg.connect (nop1, dst1)
     fg.connect (src2, nop2)
     fg.connect (nop2, dst2)
     fg.validate ()
     ts = fg.topological_sort (fg.all_blocks ())
     self.assertEqual ([src2, nop2, dst2, src1, nop1, dst1], ts)
示例#20
0
	def __init__(self, packet_sink=None):
	  
		#we want outputs of different types
		# NOTE: The output signature depends on the number of the subcarriers
		signature_sizes = [self._item_size_out, gr.sizeof_gr_complex * packet_sink._occupied_tones]
		
		#initialize hier2
		gr.hier_block2.__init__(
			self,
			"ofdm_demod",
			gr.io_signature(1, 1, packet_sink._hb.input_signature().sizeof_stream_item(0)), # Input signature
			gr.io_signaturev(2, 2, signature_sizes) # Output signature
		)
		#create blocks
		msg_source = gr.message_source(self._item_size_out, DEFAULT_MSGQ_LIMIT)
		self._msgq_out = msg_source.msgq()
		#connect
		self.connect(self, packet_sink)
		self.connect(msg_source, self)
		
		# For the vector analyzer connection
		self.connect((packet_sink, 1), (self, 1))
		
		if packet_sink._hb.output_signature().sizeof_stream_item(0):
			self.connect(packet_sink, gr.null_sink(packet_sink._hb.output_signature().sizeof_stream_item(0)))
示例#21
0
 def test_100(self):
   vlen = 256
   cp_len = 12
   
   M = 10
   N = int(3e6)
   
   uut = ofdm.frequency_shift_vcc( vlen, 1.0/vlen, cp_len )
   
   trig = [0]*M
   trig[0] = 1
   
   eps = [1.]*M
       
   src1 = gr.vector_source_c( [1.]*(M*vlen), True, vlen )
   src2 = gr.vector_source_f( eps, True )
   src3 = gr.vector_source_b( trig, True )
   dst = gr.null_sink( gr.sizeof_gr_complex * vlen )
   
   limit3 = gr.head( gr.sizeof_char, N )
   
   self.fg.connect( src1, ( uut, 0 ) )
   self.fg.connect( src2, ( uut, 1 ) )
   self.fg.connect( src3, limit3, ( uut, 2 ) )
   self.fg.connect( uut, dst )
   
   r = time_it( self.fg )
   
   print "Rate %s" % \
     ( eng_notation.num_to_str( float( ( vlen + cp_len ) * N ) / r ) )
示例#22
0
    def test_101(self):
        vlen = 256
        N = int(5e5)
        soff = 1.0
        taps = [1.0, 0.0, 2e-1 + 0.1j, 1e-4 - 0.04j]
        freqoff = 0.0
        norm_freq = freqoff / vlen
        rms_amplitude = 8000
        snr_db = 10
        snr = 10.0**(snr_db / 10.0)
        noise_sigma = sqrt(rms_amplitude**2 / snr)

        data = [1 + 1j] * vlen
        #data2 = [2] * vlen

        src = gr.vector_source_c(data, True, vlen)
        v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)

        channel = gr.channel_model(noise_sigma, norm_freq, soff, taps)

        dst = gr.null_sink(gr.sizeof_gr_complex)

        limit = gr.head(gr.sizeof_gr_complex * vlen, N)

        self.tb.connect(src, limit, v2s, channel, dst)

        r = time_it(self.tb)

        print "Rate: %s Samples/second" \
          % eng_notation.num_to_str( float(N) * vlen / r )
示例#23
0
    def test_002(self):
        vlen = 256
        subc = 208
        L = 8
        cplen = 12
        blocklen = vlen + cplen
        framelength = 11
        bits_per_subc = [2] * vlen
        data_blocks = 10

        N = int(1e9)

        # GI metric

        pre0, fd = morellimengali_designer.create(subc, vlen, L)


        ofdm_frames = \
          ofdm_frame_src( vlen, data_blocks, pre0, cplen, framelength,
                          bits_per_subc )

        #uut = ofdm.autocorrelator0( vlen, cplen )
        uut = autocorrelator(vlen, cplen)

        limit_stream = gr.head(gr.sizeof_float, N)

        self.tb.connect(ofdm_frames, uut, limit_stream,
                        gr.null_sink(gr.sizeof_float))

        #    log_to_file( self.tb, limit_stream, "data/cyclicprefix_autocorr.float" )

        r = time_it(self.tb)

        print "Expected throughput:  %s Samples/s" % (eng_notation.num_to_str(
            float(N) / r))
 def test_006_check_item_sizes (self):
     fg = self.fg
     src1 = gr.null_source (gr.sizeof_int)
     dst1 = gr.null_sink (gr.sizeof_char)
     self.assertRaises (ValueError,
                        lambda : fg.connect ((src1, 0),
                                             (dst1, 0)))
 def __init__(self, Np=32, P=128, L=2,
              filename=None, sample_type='complex', verbose=True):
     gr.top_block.__init__(self)
     if filename is None:
         src = gr.noise_source_c(gr.GR_GAUSSIAN, 1)
         if verbose:
             print "Using Gaussian noise source."
     else:
         if sample_type == 'complex':
             src = gr.file_source(gr.sizeof_gr_complex, filename, True)
         else:
             fsrc = gr.file_source(gr.sizeof_float, filename, True)
             src = gr.float_to_complex()
             self.connect(fsrc, src)
         if verbose:
             print "Reading data from %s" % filename
     if verbose:
         print "FAM configuration:"
         print "N'   = %d" % Np
         print "P    = %d" % P
         print "L    = %d" % L
         #print "Δf   = %f" % asfd
     sink = gr.null_sink(gr.sizeof_float * 2 * Np)
     self.cyclo_fam = specest.cyclo_fam(Np, P, L)
     self.connect(src, self.cyclo_fam, sink)
示例#26
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
示例#27
0
    def test_100(self):
        vlen = 256
        cp_len = 12

        M = 10
        N = int(3e6)

        uut = ofdm.frequency_shift_vcc(vlen, 1.0 / vlen, cp_len)

        trig = [0] * M
        trig[0] = 1

        eps = [1.] * M

        src1 = gr.vector_source_c([1.] * (M * vlen), True, vlen)
        src2 = gr.vector_source_f(eps, True)
        src3 = gr.vector_source_b(trig, True)
        dst = gr.null_sink(gr.sizeof_gr_complex * vlen)

        limit3 = gr.head(gr.sizeof_char, N)

        self.fg.connect(src1, (uut, 0))
        self.fg.connect(src2, (uut, 1))
        self.fg.connect(src3, limit3, (uut, 2))
        self.fg.connect(uut, dst)

        r = time_it(self.fg)

        print "Rate %s" % \
          ( eng_notation.num_to_str( float( ( vlen + cp_len ) * N ) / r ) )
 def body_109 (self):
     fg = self.fg
     src1 = gr.null_source (gr.sizeof_int)
     dst1 = gr.null_sink (gr.sizeof_int)
     fg.connect (src1, dst1)
     fg._setup_connections ()
     self.assertEqual ((2,2,1,1), all_counts ())
示例#29
0
    def __init__(self):
        grc_wxgui.top_block_gui.__init__(self, title="Top Block")

        ##################################################
        # Variables
        ##################################################
        self.samp_rate = samp_rate = 32000

        ##################################################
        # Blocks
        ##################################################
        self.nyquist_block_nyquist_0 = nyquist.nyquist()
        self.nyquist_block_nyquist_0.set_parameters("0,1,2*0.9*10,100",
                                                    "0,1,2*0.3*10.1,102.01",
                                                    "0,1,2*0.1*15.1,228.01",
                                                    "0,1,2*0.9*15,225")
        self.gr_null_source_0 = gr.null_source(gr.sizeof_float * 1)
        self.gr_null_sink_0 = gr.null_sink(gr.sizeof_float * 1)

        ##################################################
        # Connections
        ##################################################
        self.connect((self.gr_null_source_0, 0),
                     (self.nyquist_block_nyquist_0, 0))
        self.connect((self.nyquist_block_nyquist_0, 0),
                     (self.gr_null_sink_0, 0))
    def __init__(self, tx, zc, reader, rx, matched_filter,
                 reader_monitor_cmd_gate, cr, tag_monitor, amplitude):
        gr.top_block.__init__(self)

        # ASK/PSK demodulators
        to_mag_L = gr.complex_to_mag()
        to_mag_R = gr.complex_to_mag()

        # Others blocks for Buettner's reader
        samp_freq = (64 / dec_rate) * 1e6
        num_taps = int(64000 / (dec_rate * up_link_freq * 4))
        taps = [complex(1, 1)] * num_taps
        filt = gr.fir_filter_ccc(sw_dec, taps)  # Matched filter
        amp = gr.multiply_const_cc(amplitude)
        c_gate = rfid.cmd_gate(dec_rate * sw_dec, reader.STATE_PTR)

        # Null sink for terminating the Listener graph
        null_sink = gr.null_sink(gr.sizeof_float * 1)

        # Deinterleaver to separate FPGA channels
        di = gr.deinterleave(gr.sizeof_gr_complex)

        # Enable real-time scheduling
        r = gr.enable_realtime_scheduling()
        if r != gr.RT_OK:
            print "Warning: failed to enable realtime scheduling"

# Create flow-graph
        self.connect(rx, di)
        self.connect((di, 0), filt, to_mag_R, c_gate, zc, reader, amp, tx)
        self.connect((di, 1), matched_filter, to_mag_L,
                     reader_monitor_cmd_gate, cr, tag_monitor, null_sink)
示例#31
0
  def test_101(self):
    vlen = 256
    N = int( 5e5 )
    soff=1.0
    taps = [1.0,0.0,2e-1+0.1j,1e-4-0.04j]
    freqoff = 0.0
    norm_freq = freqoff / vlen
    rms_amplitude = 8000
    snr_db = 10
    snr = 10.0**(snr_db/10.0)
    noise_sigma = sqrt( rms_amplitude**2 / snr)
    
    
    
    data = [1 + 1j] * vlen
    #data2 = [2] * vlen
    
    src = gr.vector_source_c( data, True, vlen )
    v2s = gr.vector_to_stream(gr.sizeof_gr_complex,vlen)
    
    
    channel = gr.channel_model(noise_sigma,norm_freq,soff,taps)
    
    dst = gr.null_sink( gr.sizeof_gr_complex )

    limit = gr.head( gr.sizeof_gr_complex * vlen, N )
    
    
    self.tb.connect( src, limit, v2s, channel, dst )
    
    r = time_it( self.tb )
    
    print "Rate: %s Samples/second" \
      % eng_notation.num_to_str( float(N) * vlen / r ) 
    def __init__(self, rx, reader, tx):
        gr.top_block.__init__(self)

        samp_freq = (64 / dec_rate) * 1e6
        amplitude = 33000

        num_taps = int(
            64000 /
            (dec_rate * up_link_freq * 2))  #Matched filter for 1/2 cycle

        taps = [complex(1, 1)] * num_taps

        print num_taps

        filt = gr.fir_filter_ccc(sw_dec, taps)

        to_mag = gr.complex_to_mag()
        amp = gr.multiply_const_cc(amplitude)

        c_gate = rfid.cmd_gate(dec_rate * sw_dec, reader.STATE_PTR)
        zc = rfid.clock_recovery_zc_ff(samples_per_pulse, 2)

        dummy = gr.null_sink(gr.sizeof_float)
        to_complex = gr.float_to_complex()

        r = gr.enable_realtime_scheduling()
        if r != gr.RT_OK:
            print "Warning: failed to enable realtime scheduling"

        self.connect(rx, filt, to_mag, c_gate, zc, reader, amp, tx)
示例#33
0
    def __init__(self, options):
        '''
        See below for what options should hold
        '''

        gr.hier_block2.__init__(self, "transmit_path",
				gr.io_signature(1,1,gr.sizeof_char),
				gr.io_signature(1, 1, gr.sizeof_gr_complex))

        options = copy.copy(options)    # make a copy so we can destructively modify

        self._verbose      = options.verbose      # turn verbose mode on/off
        self._tx_amplitude = options.tx_amplitude # digital amp sent to radio

        self.packet_tx = ofdm_mod(options,
                                        msgq_limit=4,
                                        pad_for_usrp=False)

        self.amp = gr.multiply_const_cc(1)
        self.set_tx_amplitude(self._tx_amplitude)
        self.null_sink = gr.null_sink(gr.sizeof_char)
        self.coding_block_length = options.block_length

        # Display some information about the setup
        if self._verbose:
            self._print_verbage()

        # Create and setup transmit path flow graph
        self.connect(self.packet_tx, self.amp, self)
        # connect hier block input to null when not using streaming inputs
        self.connect(self,self.null_sink)
    def __init__(self, packet_sink=None):
        #initialize hier2
        gr.hier_block2.__init__(
            self,
            "ofdm_mod",
            gr.io_signature(
                1, 1,
                packet_sink._hb.input_signature().sizeof_stream_item(
                    0)),  # Input signature
            gr.io_signature(1, 1, self._item_size_out)  # Output signature
        )
        #create blocks
        msg_source = gr.message_source(self._item_size_out, DEFAULT_MSGQ_LIMIT)
        self._msgq_out = msg_source.msgq()
        #connect
        self.connect(self, packet_sink)
        self.connect(msg_source, self)
        if packet_sink._hb.output_signature().sizeof_stream_item(0):
            self.connect(
                packet_sink,
                gr.null_sink(
                    packet_sink._hb.output_signature().sizeof_stream_item(0)))

        self.lasttime = []
        self.chars = []
示例#35
0
    def __init__(self):
        gr.top_block.__init__(self, "Affinity Set Test")

        ##################################################
	# Variables
	##################################################
	self.samp_rate = samp_rate = 32000

	##################################################
	# Blocks
	##################################################
        vec_len = 1
	self.gr_throttle_0 = gr.throttle(gr.sizeof_gr_complex*vec_len, samp_rate)
	self.gr_null_source_0 = gr.null_source(gr.sizeof_gr_complex*vec_len)
	self.gr_null_sink_0 = gr.null_sink(gr.sizeof_gr_complex*vec_len)
	self.gr_filt_0 = gr.fir_filter_ccc(1, 40000*[0.2+0.3j,])
	self.gr_filt_1 = gr.fir_filter_ccc(1, 40000*[0.2+0.3j,])

	self.gr_filt_0.set_processor_affinity([0,])
	self.gr_filt_1.set_processor_affinity([0,1])
		
	##################################################
	# Connections
	##################################################
	self.connect((self.gr_null_source_0, 0), (self.gr_throttle_0, 0))
	self.connect((self.gr_throttle_0, 0), (self.gr_filt_0, 0))
	self.connect((self.gr_filt_0, 0), (self.gr_filt_1, 0))
	self.connect((self.gr_filt_1, 0), (self.gr_null_sink_0, 0))
示例#36
0
def qa_linker():
    import time
    from gnuradio import window
    from system import System
    from signal_psk31 import PSK31Signal

    def mag(c):
        """Magnitude of complex number."""
        return (c*c.conjugate()).real

    src = gr.wavfile_source("../example.WAV", False)
    samp_rate = 44100
    tb = gr.top_block()
    system = System(tb, src, samp_rate, throttle=False, src_is_float=True,
                    center_freq=0)
    linker = Linker(1000, 80, samp_rate)
    snk = gr.null_sink(gr.sizeof_gr_complex)
    system.connect(system.out, linker, snk)
    system.refresh()
    system.start()
    time.sleep(5)
    system.stop()
    data = linker.probe.level()
    print(data[:10])
    print(linker.samp_rate)
    plot_fft([mag(x) for x in data], linker.samp_rate)
示例#37
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'))
示例#38
0
    def __init__(self, which=''):
        gr.top_block.__init__(self, "Filter Test")

        ##################################################
        # Variables
        ##################################################
        self.samp_rate = samp_rate = 32000

        ##################################################
        # Blocks
        ##################################################
        self.gr_null_source_0 = gr.null_source(gr.sizeof_gr_complex*1)
        self.gr_null_sink_0 = gr.null_sink(gr.sizeof_gr_complex*1)
        self.blks2_rational_resampler_xxx_0 = blks2.rational_resampler_ccc(
            interpolation=3,
            decimation=7,
            taps=None,
            fractional_bw=None,
        )
        self.fir_filter_xxx_0 = filter.fir_filter_ccc(7, ([.7]*23))

        if which == 'dfir': self.filter = self.fir_filter_xxx_0
        if which == 'resamp': self.filter = self.blks2_rational_resampler_xxx_0

        ##################################################
        # Connections
        ##################################################
        self.connect((self.filter, 0), (self.gr_null_sink_0, 0))
        self.connect((self.gr_null_source_0, 0), (self.filter, 0))
    def __init__(self):
        gr.top_block.__init__(self, "Many Rate Changing")

        ##################################################
        # Variables
        ##################################################
        self.samp_rate = samp_rate = 32000

        ##################################################
        # Blocks
        ##################################################
        self.random_source_x_0 = gr.vector_source_b(
            map(int, numpy.random.randint(0, 256, 1000)), True)
        self.gr_unpacked_to_packed_xx_0 = gr.unpacked_to_packed_bb(
            2, gr.GR_LSB_FIRST)
        self.gr_packed_to_unpacked_xx_0 = gr.packed_to_unpacked_bb(
            2, gr.GR_MSB_FIRST)
        self.gr_null_sink_0_2 = gr.null_sink(gr.sizeof_char * 1)
        self.blocks_float_to_char_0 = blocks.float_to_char(1, 1)
        self.blocks_char_to_float_0 = blocks.char_to_float(1, 1)

        ##################################################
        # Connections
        ##################################################
        self.connect((self.blocks_char_to_float_0, 0),
                     (self.blocks_float_to_char_0, 0))
        self.connect((self.blocks_float_to_char_0, 0),
                     (self.gr_packed_to_unpacked_xx_0, 0))
        self.connect((self.gr_unpacked_to_packed_xx_0, 0),
                     (self.blocks_char_to_float_0, 0))
        self.connect((self.random_source_x_0, 0),
                     (self.gr_unpacked_to_packed_xx_0, 0))
        self.connect((self.gr_packed_to_unpacked_xx_0, 0),
                     (self.gr_null_sink_0_2, 0))
示例#40
0
文件: c.py 项目: 0x7678/iListener
	def __init__(self):
		#grc_wxgui.top_block_gui.__init__(self, title="Top Block")
		gr.top_block.__init__(self)
		print "abc"
		##################################################
		# Variables
		##################################################
		#self.samp_rate = samp_rate = 32000
		self.osr = 4
		self.key = ''
		self.configuration = ''

		self.clock_rate = 52e6
		self.input_rate = self.clock_rate / 72		#TODO: what about usrp value?
		self.gsm_symb_rate = 1625000.0 / 6.0
		self.sps = self.input_rate / self.gsm_symb_rate




		# configure channel filter
		filter_cutoff	= 135e3		#135,417Hz is GSM bandwidth 
		filter_t_width	= 10e3
		offset = 0.0

		##################################################
		# Blocks
		##################################################
		self.gr_null_sink_0 = gr.null_sink(gr.sizeof_gr_complex*1)

		print "Input files: ", downfile, " ", upfile
		self.gr_file_source_0 = gr.file_source(gr.sizeof_gr_complex*1, downfile, False)
		self.gr_file_source_1 = gr.file_source(gr.sizeof_gr_complex*1, upfile, False)


		filter_taps = gr.firdes.low_pass(1.0, self.input_rate, filter_cutoff, filter_t_width, gr.firdes.WIN_HAMMING)

		print len(filter_taps)

		self.filter0 = gr.freq_xlating_fir_filter_ccf(1, filter_taps, offset, self.input_rate)
		self.filter1 = gr.freq_xlating_fir_filter_ccf(1, filter_taps, offset, self.input_rate)

		self.interpolator_1 = gr.fractional_interpolator_cc(0, self.sps) 

        	self.tuner_callback = tuner(self)
	        self.synchronizer_callback = synchronizer(self)

		#self.buffer =  howto.buffer_cc()

		self.burst_cb = burst_callback(self)

		print ">>>>>Input rate: ", self.input_rate
		#self.burst = gsm.burst_cf(self.burst_cb,self.input_rate)
        	self.receiver = gsm.receiver_cf(self.tuner_callback, self.synchronizer_callback, self.osr, self.key.replace(' ', '').lower(), self.configuration.upper())
		##################################################
		# Connections
		##################################################
		#self.connect((self.gr_file_source_0, 0), (self.filter0, 0), (self.burst, 0))

		self.connect((self.gr_file_source_1, 0), (self.filter1, 0), (self.interpolator_1, 0), (self.receiver, 0))
示例#41
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)
示例#42
0
	def __init__(self):
		gr.top_block.__init__(self, "Many Rate Changing")

		##################################################
		# Variables
		##################################################
		self.samp_rate = samp_rate = 32000

		##################################################
		# Blocks
		##################################################
		self.random_source_x_0 = gr.vector_source_b(map(int, numpy.random.randint(0, 256, 1000)), True)
		self.gr_unpacked_to_packed_xx_0 = gr.unpacked_to_packed_bb(2, gr.GR_LSB_FIRST)
		self.gr_packed_to_unpacked_xx_0 = gr.packed_to_unpacked_bb(2, gr.GR_MSB_FIRST)
		self.gr_null_sink_0_2 = gr.null_sink(gr.sizeof_char*1)
		self.blocks_keep_m_in_n_0 = blocks.keep_m_in_n(gr.sizeof_float, 3, 20, 0)
		self.blocks_float_to_char_0 = blocks.float_to_char(1, 1)
		self.blocks_char_to_float_0 = blocks.char_to_float(1, 1)

		##################################################
		# Connections
		##################################################
		self.connect((self.blocks_char_to_float_0, 0), (self.blocks_keep_m_in_n_0, 0))
		self.connect((self.blocks_keep_m_in_n_0, 0), (self.blocks_float_to_char_0, 0))
		self.connect((self.blocks_float_to_char_0, 0), (self.gr_packed_to_unpacked_xx_0, 0))
		self.connect((self.gr_unpacked_to_packed_xx_0, 0), (self.blocks_char_to_float_0, 0))
		self.connect((self.random_source_x_0, 0), (self.gr_unpacked_to_packed_xx_0, 0))
		self.connect((self.gr_packed_to_unpacked_xx_0, 0), (self.gr_null_sink_0_2, 0))
示例#43
0
    def __init__(self, options):
        '''
        See below for what options should hold
        '''

        gr.hier_block2.__init__(self, "transmit_path",
                                gr.io_signature(1, 1, gr.sizeof_char),
                                gr.io_signature(1, 1, gr.sizeof_gr_complex))

        options = copy.copy(
            options)  # make a copy so we can destructively modify

        self._verbose = options.verbose  # turn verbose mode on/off
        self._tx_amplitude = options.tx_amplitude  # digital amp sent to radio

        self.packet_tx = ofdm_mod(options, msgq_limit=4, pad_for_usrp=False)

        self.amp = gr.multiply_const_cc(1)
        self.set_tx_amplitude(self._tx_amplitude)
        self.null_sink = gr.null_sink(gr.sizeof_char)
        self.coding_block_length = options.block_length

        # Display some information about the setup
        if self._verbose:
            self._print_verbage()

        # Create and setup transmit path flow graph
        self.connect(self.packet_tx, self.amp, self)
        # connect hier block input to null when not using streaming inputs
        self.connect(self, self.null_sink)
示例#44
0
	def __init__(self):
		grc_wxgui.top_block_gui.__init__(self, title="Top Block")
		_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
		self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))

		##################################################
		# Variables
		##################################################
		self.samp_rate = samp_rate = 2.4e6

		##################################################
		# Blocks
		##################################################
		self.howto_spectrum_sensing_cf_0 = howto.spectrum_sensing_cf(samp_rate,2048,16,0.001,0.0001,1.9528,True,True,0,200000.0,False,3,4,1,6)
		self.gr_null_sink_0 = gr.null_sink(gr.sizeof_float*1)
		self.fft_vxx_0 = fft.fft_vcc(2048, True, (window.blackmanharris(1024)), False, 1)
		self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 2048)
		self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 1000, 1, 0)

		##################################################
		# Connections
		##################################################
		self.connect((self.fft_vxx_0, 0), (self.howto_spectrum_sensing_cf_0, 0))
		self.connect((self.howto_spectrum_sensing_cf_0, 0), (self.gr_null_sink_0, 0))
		self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
		self.connect((self.analog_sig_source_x_0, 0), (self.blocks_stream_to_vector_0, 0))
示例#45
0
def build_block (tx_enable, rx_enable):
    max_usb_rate = 8e6                  # 8 MS/sec
    dac_freq = 128e6
    adc_freq =  64e6
    
    tx_nchan = 2
    tx_mux = 0x0000ba98
    tx_interp =  int (dac_freq / (max_usb_rate/2 * tx_nchan)) # 16
    
    rx_nchan = 2
    rx_mux = 0x00003210
    rx_decim = int ((adc_freq * rx_nchan) / (max_usb_rate/2)) # 32
    
    tb = gr.top_block ()

    if tx_enable:
        tx_src0 = gr.sig_source_c (dac_freq/tx_interp, gr.GR_CONST_WAVE, 0, 16e3, 0)
        usrp_tx = usrp.sink_c (0, tx_interp, tx_nchan, tx_mux)
        usrp_tx.set_tx_freq (0, 10e6)
        usrp_tx.set_tx_freq (1,  9e6)
        tb.connect (tx_src0, usrp_tx)

    if rx_enable:
        usrp_rx = usrp.source_c (0, rx_decim, rx_nchan, rx_mux)
        usrp_rx.set_rx_freq (0, 5.5e6)
        usrp_rx.set_rx_freq (1, 6.5e6)
        rx_dst0 = gr.null_sink (gr.sizeof_gr_complex)
        tb.connect (usrp_rx, rx_dst0)

    return tb
示例#46
0
	def __init__(self, item_size, num_inputs, num_outputs, input_index, output_index):
		"""
		Selector constructor.
		@param item_size the size of the gr data stream in bytes
		@param num_inputs the number of inputs (integer)
		@param num_outputs the number of outputs (integer)
		@param input_index the index for the source data
		@param output_index the index for the destination data
		"""
		gr.hier_block2.__init__(
			self, 'selector',
			gr.io_signature(num_inputs, num_inputs, item_size),
			gr.io_signature(num_outputs, num_outputs, item_size),
		)
		#terminator blocks for unused inputs and outputs
		self.input_terminators = [gr.null_sink(item_size) for i in range(num_inputs)]
		self.output_terminators = [gr.head(item_size, 0) for i in range(num_outputs)]
		self.copy = gr.kludge_copy(item_size)
		#connections
		for i in range(num_inputs): self.connect((self, i), self.input_terminators[i])
		for i in range(num_outputs): self.connect(gr.null_source(item_size), self.output_terminators[i], (self, i))
		self.item_size = item_size
		self.input_index = input_index
		self.output_index = output_index
		self.num_inputs = num_inputs
		self.num_outputs = num_outputs
		self._connect_current()
示例#47
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)
    def __init__(self, rx, reader, tx):
        gr.top_block.__init__(self)
               
        samp_freq = (64 / dec_rate) * 1e6
        amplitude = 33000

        num_taps = int(64000 / (dec_rate * up_link_freq * 2))  #Matched filter for 1/2 cycle

        taps = [complex(1,1)] * num_taps
        
        print num_taps

        filt = gr.fir_filter_ccc(sw_dec, taps)
        
        to_mag = gr.complex_to_mag()
        amp = gr.multiply_const_cc(amplitude)

        c_gate = rfid.cmd_gate(dec_rate * sw_dec, reader.STATE_PTR)
        zc = rfid.clock_recovery_zc_ff(samples_per_pulse, 2);
        
        dummy = gr.null_sink(gr.sizeof_float)
        to_complex = gr.float_to_complex()


        r = gr.enable_realtime_scheduling()
        if r != gr.RT_OK:
            print "Warning: failed to enable realtime scheduling"
    
        


        self.connect(rx, filt, to_mag, c_gate, zc,  reader, amp, tx);   
示例#49
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'))
示例#50
0
    def __build_graph(self, source, capture_rate):
        # tell the scope the source rate
        self.spectrum.set_sample_rate(capture_rate)
        # channel filter
        self.channel_offset = 0.0
        channel_decim = capture_rate // self.channel_rate
        channel_rate = capture_rate // channel_decim
        trans_width = 12.5e3 / 2
        trans_centre = trans_width + (trans_width / 2)
        # discriminator tap doesn't do freq. xlation, FM demodulation, etc.
        if not self.baseband_input:
            coeffs = gr.firdes.low_pass(1.0, capture_rate, trans_centre,
                                        trans_width, gr.firdes.WIN_HANN)
            self.channel_filter = gr.freq_xlating_fir_filter_ccf(
                channel_decim, coeffs, 0.0, capture_rate)
            self.set_channel_offset(0.0, 0, self.spectrum.win._units)
            # power squelch
            squelch_db = 0
            self.squelch = gr.pwr_squelch_cc(squelch_db, 1e-3, 0, True)
            self.set_squelch_threshold(squelch_db)
            # FM demodulator
            fm_demod_gain = channel_rate / (2.0 * pi * self.symbol_deviation)
            fm_demod = gr.quadrature_demod_cf(fm_demod_gain)
        # symbol filter
        symbol_decim = 1
        #symbol_coeffs = gr.firdes.root_raised_cosine(1.0, channel_rate, self.symbol_rate, 0.2, 500)
        # boxcar coefficients for "integrate and dump" filter
        samples_per_symbol = channel_rate // self.symbol_rate
        symbol_coeffs = (1.0 / samples_per_symbol, ) * samples_per_symbol
        self.symbol_filter = gr.fir_filter_fff(symbol_decim, symbol_coeffs)

        # C4FM demodulator
        autotuneq = gr.msg_queue(2)
        demod_fsk4 = op25.fsk4_demod_ff(autotuneq, channel_rate,
                                        self.symbol_rate)
        # for now no audio output
        sink = gr.null_sink(gr.sizeof_float)
        # connect it all up
        if self.baseband_input:
            self.rescaler = gr.multiply_const_ff(1)
            sinkx = gr.file_sink(gr.sizeof_float, "rx.dat")
            self.__connect([[
                source, self.rescaler, self.symbol_filter, demod_fsk4,
                self.slicer, self.p25_decoder, sink
            ], [self.symbol_filter, self.signal_scope], [demod_fsk4, sinkx],
                            [demod_fsk4, self.symbol_scope]])
            self.connect_data_scope(not self.datascope_raw_input)
        else:
            self.demod_watcher = demod_watcher(autotuneq,
                                               self.adjust_channel_offset)
            self.__connect([[
                source, self.channel_filter, self.squelch, fm_demod,
                self.symbol_filter, demod_fsk4, self.slicer, self.p25_decoder,
                sink
            ], [source, self.spectrum],
                            [self.symbol_filter, self.signal_scope],
                            [demod_fsk4, self.symbol_scope]])
示例#51
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()
示例#52
0
    def setup_flowgraph(self):

        options = self.options

        # Attempt to enable realtime scheduling
        if options.realtime:
            r = gr.enable_realtime_scheduling()
            if r == gr.RT_OK:
                options.realtime = True
                print >> sys.stderr, "Realtime scheduling ENABLED"
            else:
                options.realtime = False
                print >> sys.stderr, "Realtime scheduling FAILED"

        self.setup_timing()

        # Setup our input source
        if options.inputfile:
            self.using_usrp = False
            print >> sys.stderr, "Reading data from: " + options.inputfile
            self.source = gr.file_source(gr.sizeof_gr_complex,
                                         options.inputfile, options.fileloop)
        else:
            self.using_usrp = True
            self.setup_usrp()

        self.setup_filter()

        #create a tuner callback
        self.mean_offset = 0.0  #this is set by tuner callback
        self.burst_cb = burst_callback(self)

        # Setup flow based on decoder selection
        #	if options.decoder.count("c"):
        self.setup_c_flowgraph()
        #	elif options.decoder.count("f"):
        #		self.setup_f_flowgraph()

        self.configure_burst_decoder()

        #Hookup a vector-stream converter if we want burst output
        if self.scopes.count("b") or options.outputfile:
            self.v2s = gr.vector_to_stream(
                gr.sizeof_float, 142)  #burst output is 142 (USEFUL_BITS)
            self.connect(self.burst, self.v2s)
        else:
            self.burst_sink = gr.null_sink(gr.sizeof_float)
            self.v2s = gr.vector_to_stream(
                gr.sizeof_float, 142)  #burst output is 142 (USEFUL_BITS)
            self.connect(self.burst, self.v2s)
            self.connect(self.v2s, self.burst_sink)

        #Output file
        if options.outputfile:
            self.filesink = gr.file_sink(gr.sizeof_float, options.outputfile)
            self.connect(self.v2s, self.filesink)
示例#53
0
    def __init__(self,
                 N_id_2,
                 decim=16,
                 avg_halfframes=2 * 8,
                 freq_corr=0,
                 dump=None):
        gr.hier_block2.__init__(
            self,
            "PSS correlator",
            gr.io_signature(1, 1, gr.sizeof_gr_complex),
            gr.io_signature(1, 1, gr.sizeof_float),
        )
        vec_half_frame = 30720 * 5 / decim

        self.taps = []
        for i in range(0, 3):
            self.taps.append(
                gen_pss_td(i, N_re=2048 / decim,
                           freq_corr=freq_corr).get_data_conj_rev())
        self.corr = filter.fir_filter_ccc(1, self.taps[N_id_2])
        self.mag = gr.complex_to_mag_squared()
        self.vec = gr.stream_to_vector(gr.sizeof_float * 1, vec_half_frame)
        self.deint = gr.deinterleave(gr.sizeof_float * vec_half_frame)
        self.add = gr.add_vff(vec_half_frame)
        self.argmax = gr.argmax_fs(vec_half_frame)
        self.null = gr.null_sink(gr.sizeof_short * 1)
        self.max = gr.max_ff(vec_half_frame)
        self.to_float = gr.short_to_float(1, 1. / decim)
        self.interleave = gr.interleave(gr.sizeof_float)
        #self.framestart = gr.add_const_ii(-160-144*5-2048*6+30720*5)

        self.connect(self, self.corr, self.mag, self.vec)
        self.connect((self.argmax, 1), self.null)
        #self.connect(self.argmax, self.to_float, self.to_int, self.framestart, self)
        self.connect(self.argmax, self.to_float, self.interleave, self)
        self.connect(self.max, (self.interleave, 1))

        if avg_halfframes == 1:
            self.connect(self.vec, self.argmax)
            self.connect(self.vec, self.max)
        else:
            self.connect(self.vec, self.deint)
            self.connect(self.add, self.argmax)
            self.connect(self.add, self.max)
            for i in range(0, avg_halfframes):
                self.connect((self.deint, i), (self.add, i))

        if dump != None:
            self.connect(
                self.mag,
                gr.file_sink(gr.sizeof_float, dump + "_pss_corr_f.cfile"))
            self.connect(
                self.add,
                gr.file_sink(gr.sizeof_float * vec_half_frame,
                             dump + "_pss_corr_add_f.cfile"))
示例#54
0
文件: dabp_msc.py 项目: rpgsystem/sdr
 def __init__(self, mode, freq, gain, conf, subchid, record=None, usrp=True):
     gr.top_block.__init__(self)
     
     if usrp: # set up usrp source
         src = dabp_usrp.setup_usrp(freq, gain)
     else: # set up sample file source
         sinput = gr.file_source(gr.sizeof_short, samp.encode('ascii'), False)
         src = gr.interleaved_short_to_complex()
         self.connect(sinput, src)
         
     # channel configuration
     cc = dabp.channel_conf(conf)
     #sys.stderr.write("Playing Channel: "+cc.get_label(options.subchid)+"\n")
     
     start_addr = cc.get_start_addr(subchid)
     subchsz = cc.get_subchsz(subchid)
     optprot = cc.get_optprot(subchid)
     #print "start_addr=%d, subchsz=%d, optprot=%d" % (start_addr, subchsz, optprot)
     
     param = dabp.parameters(mode)
     
     # null symbol detector
     samples_per_null_sym=param.get_Nnull()
     #print "samples per null symbol : %d" % samples_per_null_sym
     nulldet = dabp.detect_null(samples_per_null_sym)
     # ofdm demod
     demod = dabp.ofdm_demod(mode)
     # FIC/MSC demultiplexer
     demux = dabp.fic_msc_demux(1, mode)
     
     cifsz = param.get_cifsz()
     scs = dabp.subchannel_selector(cifsz,start_addr,subchsz)
     intlv = dabp.time_deinterleaver(subchsz)
     punc = dabp.depuncturer(subchsz,optprot)
     I = punc.getI()
     vit = dabp.vitdec(I)
     scram = dabp.scrambler(I)
     len_logfrm=scram.get_nbytes()
     sync = dabp.super_frame_sync(len_logfrm)
     subchidx = sync.get_subchidx()
     rs = dabp.super_frame_rsdec(subchidx)
     if record == None:
         mplayer = subprocess.Popen(['mplayer', '-af', 'volume=20', '-ac', '+faad', '-rawaudio', 'format=0xff', '-demuxer', '+rawaudio','-'], stdin=subprocess.PIPE)
         dst = dabp.super_frame_sink(subchidx, mplayer.stdin.fileno())
     else:
         dst = dabp.super_frame_sink(subchidx, record.encode('ascii'))
     
     nullsink = gr.null_sink(gr.sizeof_char)
     # connect everything
     self.connect(src, nulldet)
     self.connect(src, (demod,0))
     self.connect(nulldet, (demod,1))
     self.connect((demod,0), demux, scs, intlv, punc, vit, scram, sync, rs, dst)
     self.connect((demod,1), nullsink)
示例#55
0
 def build_graph(self, device, speed):
     self.src = gr.sig_source_s(2, gr.GR_CONST_WAVE, 1, 0, 1)
     self.sink = gr.null_sink(gr.sizeof_short)
     self.spi = gr_spi.gr_spi_srcsink_ss()
     sys.stdout.write("Blocks created\n")
     self.spi.open_spi(device, speed)
     sys.stdout.write("SPI device open\n")
     self.connect(self.src, self.spi)
     sys.stdout.write("Source connected\n")
     self.connect(self.spi, self.sink)
     sys.stdout.write("Sink connected\n")
示例#56
0
    def __init__(self):
        grc_wxgui.top_block_gui.__init__(self, title="My Second Msg Block")

        ##################################################
        # Variables
        ##################################################
        self.samp_rate = samp_rate = 25e6

        ##################################################
        # Blocks
        ##################################################
        self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
            self.GetWin(),
            baseband_freq=0,
            y_per_div=10,
            y_divs=10,
            ref_level=0,
            ref_scale=2.0,
            sample_rate=samp_rate,
            fft_size=1024,
            fft_rate=15,
            average=False,
            avg_alpha=None,
            title="FFT Plot",
            peak_hold=False,
        )
        self.Add(self.wxgui_fftsink2_0.win)
        self.usrp_source = uhd.usrp_source(
            device_addr="",
            stream_args=uhd.stream_args(
                cpu_format="fc32",
                channels=range(1),
            ),
        )
        self.usrp_source.set_samp_rate(samp_rate)
        self.usrp_source.set_center_freq(105e6, 0)
        self.usrp_source.set_gain(15, 0)
        self.usrp_source.set_antenna("RX2", 0)
        self.my_second_msg_block_0 = dt.my_second_msg_block(
            "95e6,605e6,915e6,880e6,1986e6")
        self.heart_beat_0_0 = precog.heart_beat(5, "hello", "world")
        self.heart_beat_0 = precog.heart_beat(1, "hello", "world")
        self.gr_null_sink_0 = gr.null_sink(gr.sizeof_char * 1)
        self.extras_pmt_rpc_0 = gr_extras.pmt_rpc(obj=self, result_msg=False)

        ##################################################
        # Connections
        ##################################################
        self.connect((self.heart_beat_0, 0), (self.my_second_msg_block_0, 0))
        self.connect((self.heart_beat_0_0, 0), (self.my_second_msg_block_0, 1))
        self.connect((self.my_second_msg_block_0, 1),
                     (self.extras_pmt_rpc_0, 0))
        self.connect((self.usrp_source, 0), (self.wxgui_fftsink2_0, 0))
        self.connect((self.my_second_msg_block_0, 0), (self.gr_null_sink_0, 0))
示例#57
0
	def test_001_srcsink_ss (self):
		src = gr.null_source(gr.sizeof_short)
		spi = gr_spi.spi_srcsink_ss()
		spi.open_spi("/dev/null",1000000)
		sink = gr.null_sink(gr.sizeof_short)
		self.fg.connect(src,0,spi,0)
		self.fg.connect(spi,sink)
		self.fg.start()
		time.sleep(0.5)
		self.fg.stop()
		spi.close_spi()