def __init__(self): gr.top_block.__init__(self) usage = "%prog: [options] filename" parser = OptionParser(option_class=eng_option, usage=usage) parser.add_option("-r", "--sample-rate", type="eng_float", default=48000, help="set sample rate to RATE (48000)") parser.add_option("-N", "--samples", type="eng_float", default=None, help="number of samples to record") (options, args) = parser.parse_args () if len(args) != 1 or options.samples is None: parser.print_help() raise SystemExit, 1 sample_rate = int(options.sample_rate) ampl = 0.1 src0 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 350, ampl) src1 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 440, ampl) head0 = gr.head(gr.sizeof_float, int(options.samples)) head1 = gr.head(gr.sizeof_float, int(options.samples)) dst = gr.wavfile_sink(args[0], 2, int(options.sample_rate), 16) self.connect(src0, head0, (dst, 0)) self.connect(src1, head1, (dst, 1))
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) parser.add_option( "-O", "--audio-output", type="string", default="", help="pcm output device name. E.g., hw:0,0 or /dev/dsp") parser.add_option("-r", "--sample-rate", type="eng_float", default=48000, help="set sample rate to RATE (48000)") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() raise SystemExit, 1 sample_rate = int(options.sample_rate) ampl = 0.1 src0 = gr.sig_source_f(sample_rate, gr.GR_SIN_WAVE, 350, ampl) src1 = gr.sig_source_f(sample_rate, gr.GR_SIN_WAVE, 440, ampl) dst = audio.sink(sample_rate, options.audio_output) self.connect(src0, (dst, 0)) self.connect(src1, (dst, 1))
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) parser.add_option("-O", "--audio-output", type="string", default="", help="pcm output device name") parser.add_option("-r", "--sample-rate", type="eng_float", default=192000, help="set sample rate to RATE (192000)") parser.add_option("-f", "--frequency", type="eng_float", default=1000) parser.add_option("-a", "--amplitude", type="eng_float", default=0.5) (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() raise SystemExit, 1 sample_rate = int(options.sample_rate) ampl = float(options.amplitude) pulse_freq = 1.0 # 1Hz pulse_dc = 0.1 # Low DC value to give high/low value rather than on/off if ampl > 1.0: ampl = 1.0 osc = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, options.frequency, ampl) pulse = gr.sig_source_f (sample_rate, gr.GR_SQR_WAVE, pulse_freq, .8, pulse_dc) mixer = gr.multiply_ff () self.connect (osc, (mixer, 0)) self.connect (pulse, (mixer, 1)) dst = audio.sink (sample_rate, options.audio_output, True) self.connect (mixer, dst)
def __init__(self): gr.top_block.__init__(self) usage = "%prog: [options] filename" parser = OptionParser(option_class=eng_option, usage=usage) parser.add_option("-r", "--sample-rate", type="eng_float", default=48000, help="set sample rate to RATE (48000)") parser.add_option("-N", "--samples", type="eng_float", default=None, help="number of samples to record") (options, args) = parser.parse_args() if len(args) != 1 or options.samples is None: parser.print_help() raise SystemExit, 1 sample_rate = int(options.sample_rate) ampl = 0.1 src0 = gr.sig_source_f(sample_rate, gr.GR_SIN_WAVE, 350, ampl) src1 = gr.sig_source_f(sample_rate, gr.GR_SIN_WAVE, 440, ampl) head0 = gr.head(gr.sizeof_float, int(options.samples)) head1 = gr.head(gr.sizeof_float, int(options.samples)) dst = gr.wavfile_sink(args[0], 2, int(options.sample_rate), 16) self.connect(src0, head0, (dst, 0)) self.connect(src1, head1, (dst, 1))
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.variable_slider_0 = variable_slider_0 = 30 self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## _variable_slider_0_sizer = wx.BoxSizer(wx.VERTICAL) self._variable_slider_0_text_box = forms.text_box( parent=self.GetWin(), sizer=_variable_slider_0_sizer, value=self.variable_slider_0, callback=self.set_variable_slider_0, label='variable_slider_0', converter=forms.float_converter(), proportion=0, ) self._variable_slider_0_slider = forms.slider( parent=self.GetWin(), sizer=_variable_slider_0_sizer, value=self.variable_slider_0, callback=self.set_variable_slider_0, minimum=0, maximum=100, num_steps=100, style=wx.SL_HORIZONTAL, cast=float, proportion=1, ) self.Add(_variable_slider_0_sizer) self.sbfan_0 = sbfan.sbfan(1,0,0) self.plot_sink_0 = plot_sink.plot_sink_f( self.GetWin(), title="Scope Plot", vlen=1, decim=1, gsz=1000, zoom=0, ) self.Add(self.plot_sink_0.win) self.gr_sig_source_x_0 = gr.sig_source_f(samp_rate, gr.GR_SIN_WAVE, 1000, 30, 0) self.gr_delay_0 = gr.delay(gr.sizeof_float*1, 5) self.gr_add_const_vxx_0 = gr.add_const_vff((30, )) self.const_source_x_0 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 40) ################################################## # Connections ################################################## self.connect((self.const_source_x_0, 0), (self.sbfan_0, 0)) self.connect((self.gr_sig_source_x_0, 0), (self.gr_add_const_vxx_0, 0)) self.connect((self.sbfan_0, 0), (self.plot_sink_0, 0)) self.connect((self.gr_add_const_vxx_0, 0), (self.gr_delay_0, 0)) self.connect((self.gr_delay_0, 0), (self.sbfan_0, 1))
def __init__(self, fd, M, sample_rate): gr.hier_block2.__init__(self, "Rayleigh Channel", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_gr_complex)) self.M = M self.sample_rate = sample_rate n = range(1, M + 1) N = 4 * M + 2 f_n = [fd * math.cos(2 * math.pi * x / N) for x in n] beta_n = [math.pi / M * x for x in n] a_n = [2 * math.cos(x) for x in beta_n] a_n.append(math.sqrt(2) * math.cos(math.pi / 4)) a_n = [x * 2 / math.sqrt(N) for x in a_n] b_n = [2 * math.sin(x) for x in beta_n] b_n.append(math.sqrt(2) * math.sin(math.pi / 4)) b_n = [x * 2 / math.sqrt(N) for x in b_n] f_n.append(fd) self.sin_real = [ gr.sig_source_f(self.sample_rate, gr.GR_COS_WAVE, f_n[i], a_n[i]) for i in range(M + 1) ] self.sin_imag = [ gr.sig_source_f(self.sample_rate, gr.GR_COS_WAVE, f_n[i], b_n[i]) for i in range(M + 1) ] self.add_real = gr.add_ff(1) self.add_imag = gr.add_ff(1) for i in range(M + 1): self.connect(self.sin_real[i], (self.add_real, i)) for i in range(M + 1): self.connect(self.sin_imag[i], (self.add_imag, i)) self.ftoc = gr.float_to_complex(1) self.connect(self.add_real, (self.ftoc, 0)) self.connect(self.add_imag, (self.ftoc, 1)) self.mulc = gr.multiply_const_cc((0.5)) #self.divide = gr.divide_cc(1) #self.connect(self,(self.divide,0)) #self.connect(self.ftoc,(self.divide,1)) #self.connect(self.divide, self) self.prod = gr.multiply_cc(1) self.connect(self, (self.prod, 0)) self.connect(self.ftoc, self.mulc, (self.prod, 1)) self.connect(self.prod, self)
def __init__(self): gr.top_block.__init__(self) sample_rate = 32000 ampl = 0.1 print('sample_rate =', sample_rate) src0 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 350, ampl) src1 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 440, ampl) dst = audio.sink (sample_rate, "") self.connect (src0, (dst, 0)) self.connect (src1, (dst, 1))
def build_graph (): sampling_freq=48000 ampl=0.1 fg=gr.top_block() src0=gr.sig_source_f(sampling_freq,gr.GR_SIN_WAVE,350,ampl) src1=gr.sig_source_f(sampling_freq,gr.GR_SIN_WAVE,440,ampl) dst=audio.sink(sampling_freq) fg.connect((src0,0),(dst,0)) fg.connect((src1,0),(dst,1)) return fg
def build_graph (): sampling_freq = 32000 ampl = 0.1 tb = gr.top_block () src0 = gr.sig_source_f (sampling_freq, gr.GR_SIN_WAVE, 350, ampl) src1 = gr.sig_source_f (sampling_freq, gr.GR_SIN_WAVE, 440, ampl) dst = audio.sink (sampling_freq) tb.connect (src0, (dst, 0)) tb.connect (src1, (dst, 1)) return tb
def build_graph(): sampling_freq = 32000 ampl = 0.1 tb = gr.top_block() src0 = gr.sig_source_f(sampling_freq, gr.GR_SIN_WAVE, 350, ampl) src1 = gr.sig_source_f(sampling_freq, gr.GR_SIN_WAVE, 440, ampl) dst = audio.sink(sampling_freq) tb.connect(src0, (dst, 0)) tb.connect(src1, (dst, 1)) return tb
def _get_gauss_rand_proc_c(self): """ Returns the Gaussian random process. """ spec_getter = getattr(self.model, 'get_' + self.spec_type) if self.spec_type in self.model.specs_odd: from winelo.channel import spec2soc soc = spec2soc(spec_getter(), method=self.method, N=self.N) sources = [] adder = gr.add_cc() for idx, (freq, ampl) in enumerate(soc.get_soc()): sources.append(gr.sig_source_c(self.sample_rate, gr.GR_COS_WAVE, freq, ampl)) self.connect(sources[idx], gr.skiphead(gr.sizeof_gr_complex, randint(low=0, high=self.sample_rate)), (adder, idx)) return adder elif self.spec_type in self.model.specs_even: from winelo.channel import spec2sos # real part of the gaussian random process sos_real = spec2sos(spec_getter(), method=self.method, N=self.N) sources_real = [] adder_real = gr.add_ff() for idx, (freq, ampl) in enumerate(sos_real.get_sos()): sources_real.append(gr.sig_source_f(self.sample_rate, gr.GR_COS_WAVE, freq, ampl)) self.connect(sources_real[idx], gr.skiphead(gr.sizeof_float, randint(low=0, high=self.sample_rate)), (adder_real, idx)) # imaginary part of the gaussian random process sos_imaginary = spec2sos(spec_getter(), method=self.method, N=self.N + 1) sources_imag = [] adder_imag = gr.add_ff() for idx, (freq, ampl) in enumerate(sos_imaginary.get_sos()): sources_imag.append(gr.sig_source_f(self.sample_rate, gr.GR_COS_WAVE, freq, ampl)) self.connect(sources_imag[idx], gr.skiphead(gr.sizeof_float, randint(low=0, high=self.sample_rate)), (adder_imag, idx)) float2complex = gr.float_to_complex() self.connect(adder_real, (float2complex, 0)) self.connect(adder_imag, (float2complex, 1)) return float2complex else: print 'You picked a non-existant Doppler spectrum' print 'Pick one of the following: ', \ self.model.specs_even + self.model.specs_odd return None
def __init__(self): gr.top_block.__init__(self) Rs = 8000 f1 = 100 f2 = 200 npts = 2048 self.qapp = QtGui.QApplication(sys.argv) src1 = gr.sig_source_f(Rs, gr.GR_SIN_WAVE, f1, 0.1, 0) src2 = gr.sig_source_f(Rs, gr.GR_SIN_WAVE, f2, 0.1, 0) src = gr.add_ff() thr = gr.throttle(gr.sizeof_float, 100*npts) noise = gr.noise_source_f(gr.GR_GAUSSIAN, 0.001) add = gr.add_ff() self.snk1 = qtgui.time_sink_f(npts, Rs, "Complex Time Example", 3) self.connect(src1, (src,0)) self.connect(src2, (src,1)) self.connect(src, thr, (add,0)) self.connect(noise, (add,1)) self.connect(add, self.snk1) self.connect(src1, (self.snk1, 1)) self.connect(src2, (self.snk1, 2)) self.ctrl_win = control_box() self.ctrl_win.attach_signal1(src1) self.ctrl_win.attach_signal2(src2) # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt4.QtGui.QWidget pyWin = sip.wrapinstance(pyQt, QtGui.QWidget) # Example of using signal/slot to set the title of a curve pyWin.connect(pyWin, QtCore.SIGNAL("setTitle(int, QString)"), pyWin, QtCore.SLOT("setTitle(int, QString)")) pyWin.emit(QtCore.SIGNAL("setTitle(int, QString)"), 0, "sum") self.snk1.set_title(1, "src1") self.snk1.set_title(2, "src2") # Can also set the color of a curve #self.snk1.set_color(5, "blue") #pyWin.show() self.main_box = dialog_box(pyWin, self.ctrl_win) self.main_box.show()
def __init__(self): gr.top_block.__init__(self) sample_rate = 48000 ampl = 0.1 src0 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 200, ampl) src1 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 1000, ampl) dst = audio.sink (sample_rate, "") self.connect (src0, (dst, 0)) self.connect (src1, (dst, 1))
def __init__(self,fd,M,sample_rate): gr.hier_block2.__init__(self,"Rayleigh Channel", gr.io_signature(1,1,gr.sizeof_gr_complex), gr.io_signature(1,1,gr.sizeof_gr_complex)) self.M = M self.sample_rate = sample_rate n=range(1,M+1) N = 4*M+2 f_n= [fd*math.cos(2*math.pi*x/N) for x in n] beta_n = [math.pi/M*x for x in n] a_n = [2*math.cos(x) for x in beta_n] a_n.append(math.sqrt(2)*math.cos(math.pi/4)) a_n = [x*2/math.sqrt(N) for x in a_n] b_n= [2*math.sin(x) for x in beta_n] b_n.append(math.sqrt(2)*math.sin(math.pi/4)) b_n = [x*2/math.sqrt(N) for x in b_n] f_n.append(fd) self.sin_real = [gr.sig_source_f(self.sample_rate,gr.GR_COS_WAVE,f_n[i],a_n[i]) for i in range(M+1)] self.sin_imag = [gr.sig_source_f(self.sample_rate,gr.GR_COS_WAVE,f_n[i],b_n[i]) for i in range(M+1)] self.add_real = gr.add_ff(1) self.add_imag = gr.add_ff(1) for i in range (M+1): self.connect(self.sin_real[i],(self.add_real,i)) for i in range (M+1): self.connect(self.sin_imag[i],(self.add_imag,i)) self.ftoc = gr.float_to_complex(1) self.connect(self.add_real,(self.ftoc,0)) self.connect(self.add_imag,(self.ftoc,1)) self.mulc = gr.multiply_const_cc((0.5)) #self.divide = gr.divide_cc(1) #self.connect(self,(self.divide,0)) #self.connect(self.ftoc,(self.divide,1)) #self.connect(self.divide, self) self.prod = gr.multiply_cc(1) self.connect(self,(self.prod,0)) self.connect(self.ftoc,self.mulc,(self.prod,1)) self.connect(self.prod, self)
def __init__(self, host, port, pkt_size, sample_rate, eof): gr.top_block.__init__(self, "dial_tone_source") amplitude = 0.3 src0 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 350, amplitude) src1 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 440, amplitude) add = gr.add_ff() # Throttle needed here to account for the other side's audio card sampling rate thr = gr.throttle(gr.sizeof_float, sample_rate) sink = gr.udp_sink(gr.sizeof_float, host, port, pkt_size, eof=eof) self.connect(src0, (add, 0)) self.connect(src1, (add, 1)) self.connect(add, thr, sink)
def __init__(self, src, dst, port, pkt_size, sample_rate): gr.top_block.__init__(self, "dial_tone_source") amplitude = 0.3 src0 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 350, amplitude) src1 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 440, amplitude) add = gr.add_ff() # Throttle needed here to account for the other side's audio card sampling rate thr = gr.throttle(gr.sizeof_float, sample_rate) sink = gr.udp_sink(gr.sizeof_float, src, 0, dst, port, pkt_size) self.connect(src0, (add, 0)) self.connect(src1, (add, 1)) self.connect(add, thr, sink)
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv) # build our flow graph input_rate = 20.48e3 # Generate a real and complex sinusoids src1 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 2.21e3, 1) src2 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 2.21e3, 1) # We add these throttle blocks so that this demo doesn't # suck down all the CPU available. Normally you wouldn't use these. thr1 = gr.throttle(gr.sizeof_float, input_rate) thr2 = gr.throttle(gr.sizeof_gr_complex, input_rate) sink1 = number_sink_f (panel, unit='V',label="Real Data", avg_alpha=0.001, sample_rate=input_rate, minval=-1, maxval=1, ref_level=0, decimal_places=3) vbox.Add (sink1.win, 1, wx.EXPAND) sink2 = number_sink_c (panel, unit='V',label="Complex Data", avg_alpha=0.001, sample_rate=input_rate, minval=-1, maxval=1, ref_level=0, decimal_places=3) vbox.Add (sink2.win, 1, wx.EXPAND) self.connect (src1, thr1, sink1) self.connect (src2, thr2, sink2)
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 __init__(self, frame, panel, vbox, argv): stdgui.gui_flow_graph.__init__ (self, frame, panel, vbox, argv) #number_size = 256 # build our flow graph input_rate = 20.48e3 # Generate a complex sinusoid src1 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 2e3, 1) #src1 = gr.sig_source_c (input_rate, gr.GR_CONST_WAVE, 5.75e3, 1) # We add these throttle blocks so that this demo doesn't # suck down all the CPU available. Normally you wouldn't use these. thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate) #sink1 = number_sink_c (self, panel, label="Complex Data", number_size=number_size, # sample_rate=input_rate, base_value=100e3, # ref_level=0, decimal_places=3) #vbox.Add (sink1.win, 1, wx.EXPAND) #self.connect (src1, thr1, sink1) src2 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 2e3, 1) #src2 = gr.sig_source_f (input_rate, gr.GR_CONST_WAVE, 5.75e3, 1) thr2 = gr.throttle(gr.sizeof_float, input_rate) sink2 = number_sink_f (self, panel, unit='Hz',label="Real Data", avg_alpha=0.001,#number_size=number_size*2, sample_rate=input_rate, base_value=100e3, ref_level=0, decimal_places=3) vbox.Add (sink2.win, 1, wx.EXPAND) sink3 = number_sink_c (self, panel, unit='V',label="Complex Data", avg_alpha=0.001,#number_size=number_size*2, sample_rate=input_rate, base_value=0, ref_level=0, decimal_places=3) vbox.Add (sink3.win, 1, wx.EXPAND) self.connect (src2, thr2, sink2) self.connect (src1, thr1, sink3)
def __init__(self, app, samp_rate, at, filename, repeat, sine): ''' in: - app = object of type RXApp - samp_rate = sample rate in Hertz - at = attenuation factor - filename = filename - repeat = if True them reads in a loop the file - sine ''' gr.hier_block2.__init__(self, "RXData", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, gr.sizeof_gr_complex)) # instance variables self.app = app if sine: self.fileSrc = gr.sig_source_f(samp_rate, gr.GR_SIN_WAVE, 1000, 1.0) else: self.fileSrc = gr.file_source(gr.sizeof_float*1, filename, repeat) # self.fileSrc = gr.sig_source_f(samp_rate, gr.GR_SIN_WAVE, 1000, 1.0) # self.fileSrc = gr.sig_source_f(samp_rate, gr.GR_CONST_WAVE, 1000, 1.0) self.mulitplyCte = gr.multiply_const_vff((at, )) self.f2c = gr.float_to_complex(1) #EO instance variables self.__makeConnections()
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) parser.add_option("-O", "--audio-output", type="string", default="", help="pcm output device name. E.g., hw:0,0 or /dev/dsp") parser.add_option("-r", "--sample-rate", type="eng_float", default=48000, help="set sample rate to RATE (48000)") parser.add_option("-D", "--dont-block", action="store_false", default=True, dest="ok_to_block") (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() raise SystemExit, 1 sample_rate = int(options.sample_rate) ampl = 0.1 src0 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 650, ampl) dst = audio.sink (sample_rate, options.audio_output, options.ok_to_block) self.connect (src0, (dst, 0))
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.plot_sink_0 = plot_sink.plot_sink_f( self.GetWin(), title="Scope Plot", vlen=1, decim=1, ) self.Add(self.plot_sink_0.win) self.gr_vector_sink_x_0 = gr.vector_sink_f(1) self.gr_serial_0 = gr_ser.ser() self.gr_serial_0.set_parameters("/dev/ttyACM1", 9600, 8, "N", 1) self.const_source_x_0 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 1) ################################################## # Connections ################################################## self.connect((self.gr_serial_0, 0), (self.gr_vector_sink_x_0, 0)) self.connect((self.gr_serial_0, 0), (self.plot_sink_0, 0)) self.connect((self.const_source_x_0, 0), (self.gr_serial_0, 0))
def test_fff_000(self): N = 1000 # number of samples to use fs = 1000 # baseband sampling rate rrate = 1.123 # resampling rate nfilts = 32 freq = 100 signal = gr.sig_source_f(fs, gr.GR_SIN_WAVE, freq, 1) head = gr.head(gr.sizeof_float, N) pfb = filter.pfb_arb_resampler_fff(rrate, taps) snk = gr.vector_sink_f() self.tb.connect(signal, head, pfb, snk) self.tb.run() Ntest = 50 L = len(snk.data()) t = map(lambda x: float(x) / (fs * rrate), xrange(L)) phase = 0.53013 expected_data = map( lambda x: math.sin(2. * math.pi * freq * x + phase), t) dst_data = snk.data() self.assertFloatTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 3)
def __init__(self, atten=0, fd=50, fadeMode=0): gr.top_block.__init__(self, "Static RF or Single Path Rayleigh Faded RF") ################################################## # Parameters ################################################## self.atten = atten self.fd = fd self.fadeMode = fadeMode ################################################## # Variables ################################################## self.usrpRate = usrpRate = 250e3 self.fdTs = fdTs = fd * (1.0 / usrpRate) self.centreFreq = centreFreq = 1e6 self.baseband_multiplier = baseband_multiplier = 0.25 ################################################## # Blocks ################################################## self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer( ("0.0.0.0", 1234), allow_none=True) self.xmlrpc_server_0.register_instance(self) threading.Thread(target=self.xmlrpc_server_0.serve_forever).start() self.uhd_usrp_sink_0_0_0 = uhd.usrp_sink( device_addr="", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_sink_0_0_0.set_subdev_spec("A:AB", 0) self.uhd_usrp_sink_0_0_0.set_samp_rate(usrpRate) self.uhd_usrp_sink_0_0_0.set_center_freq(centreFreq, 0) self.uhd_usrp_sink_0_0_0.set_gain(0, 0) self.rccBlocks_channelModel_cc_0 = rccBlocks.channelModel_cc( randint(-10000, 0), fdTs, 1.0, False, bool(fadeMode)) self.rccBlocks_VNXLabBrick_0 = rccBlocks.VNXLabBrick(atten) self.const_source_x_0_0 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 1.0) self.const_source_x_0 = gr.sig_source_c(0, gr.GR_CONST_WAVE, 0, 0, 1.0 + 1j) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float * 1, usrpRate) self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vcc( (baseband_multiplier, )) ################################################## # Connections ################################################## self.connect((self.const_source_x_0, 0), (self.rccBlocks_channelModel_cc_0, 0)) self.connect((self.blocks_multiply_const_vxx_1, 0), (self.uhd_usrp_sink_0_0_0, 0)) self.connect((self.const_source_x_0_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.rccBlocks_VNXLabBrick_0, 0)) self.connect((self.rccBlocks_channelModel_cc_0, 0), (self.blocks_multiply_const_vxx_1, 0))
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) parser.add_option("-O", "--audio-output", type="string", default="", help="pcm output device name. E.g., hw:0,0 or /dev/dsp") parser.add_option("-i", "--input-rate", type="eng_float", default=8000, help="set input sample rate to RATE (%default)") parser.add_option("-o", "--output-rate", type="eng_float", default=48000, help="set output sample rate to RATE (%default)") (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() raise SystemExit, 1 input_rate = int(options.input_rate) output_rate = int(options.output_rate) interp = gru.lcm(input_rate, output_rate) / input_rate decim = gru.lcm(input_rate, output_rate) / output_rate print "interp =", interp print "decim =", decim ampl = 0.1 src0 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 650, ampl) rr = blks2.rational_resampler_fff(interp, decim) dst = audio.sink (output_rate, options.audio_output) self.connect (src0, rr, (dst, 0))
def __init__(self, sample_rate, tone_freq): gr.hier_block2.__init__(self, "ctcss_gen_f", gr.io_signature(0, 0, 0), # Input signature gr.io_signature(1, 1, gr.sizeof_float)) # Output signature self.plgen = gr.sig_source_f(sample_rate, gr.GR_SIN_WAVE, tone_freq, 0.1, 0.0) self.connect(self.plgen, self)
def test_001_ff(self): N = 10000 # number of samples to use fs = 1000 # baseband sampling rate rrate = 1.123 # resampling rate freq = 10 signal = gr.sig_source_f(fs, gr.GR_SIN_WAVE, freq, 1) head = gr.head(gr.sizeof_float, N) op = filter.fractional_interpolator_ff(0, rrate) snk = gr.vector_sink_f() self.tb.connect(signal, head, op, snk) self.tb.run() import time time.sleep(2) Ntest = 5000 L = len(snk.data()) t = map(lambda x: float(x)/(fs/rrate), xrange(L)) phase = 0.1884 expected_data = map(lambda x: math.sin(2.*math.pi*freq*x+phase), t) dst_data = snk.data() self.assertFloatTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 3)
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv) fft_size = 256 # build our flow graph input_rate = 20.000e3 # Generate a complex sinusoid src1 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 5.75e3, 1000) #src1 = gr.sig_source_c (input_rate, gr.GR_CONST_WAVE, 5.75e3, 1000) # We add these throttle blocks so that this demo doesn't # suck down all the CPU available. Normally you wouldn't use these. thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate) sink1 = ra_fft_sink_c (panel, title="Complex Data", fft_size=fft_size, sample_rate=input_rate, baseband_freq=100e3, ref_level=60, y_per_div=10) vbox.Add (sink1.win, 1, wx.EXPAND) self.connect (src1, thr1, sink1) src2 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 5.75e3, 1000) #src2 = gr.sig_source_f (input_rate, gr.GR_CONST_WAVE, 5.75e3, 1000) thr2 = gr.throttle(gr.sizeof_float, input_rate) sink2 = ra_fft_sink_f (panel, title="Real Data", fft_size=fft_size*2, sample_rate=input_rate, baseband_freq=100e3, ref_level=60, y_per_div=10) vbox.Add (sink2.win, 1, wx.EXPAND) self.connect (src2, thr2, sink2)
def set_waveform(self, type): self.lock() self.disconnect_all() if type == gr.GR_SIN_WAVE or type == gr.GR_CONST_WAVE: self._src = gr.sig_source_c( self[SAMP_RATE_KEY], # Sample rate type, # Waveform type self[WAVEFORM_FREQ_KEY], # Waveform frequency self[AMPLITUDE_KEY], # Waveform amplitude self[WAVEFORM_OFFSET_KEY]) # Waveform offset elif type == gr.GR_GAUSSIAN or type == gr.GR_UNIFORM: self._src = gr.noise_source_c(type, self[AMPLITUDE_KEY]) elif type == "2tone": self._src1 = gr.sig_source_c(self[SAMP_RATE_KEY], gr.GR_SIN_WAVE, self[WAVEFORM_FREQ_KEY], self[AMPLITUDE_KEY] / 2.0, 0) if (self[WAVEFORM2_FREQ_KEY] is None): self[WAVEFORM2_FREQ_KEY] = -self[WAVEFORM_FREQ_KEY] self._src2 = gr.sig_source_c(self[SAMP_RATE_KEY], gr.GR_SIN_WAVE, self[WAVEFORM2_FREQ_KEY], self[AMPLITUDE_KEY] / 2.0, 0) self._src = gr.add_cc() self.connect(self._src1, (self._src, 0)) self.connect(self._src2, (self._src, 1)) elif type == "sweep": # rf freq is center frequency # waveform_freq is total swept width # waveform2_freq is sweep rate # will sweep from (rf_freq-waveform_freq/2) to (rf_freq+waveform_freq/2) if self[WAVEFORM2_FREQ_KEY] is None: self[WAVEFORM2_FREQ_KEY] = 0.1 self._src1 = gr.sig_source_f(self[SAMP_RATE_KEY], gr.GR_TRI_WAVE, self[WAVEFORM2_FREQ_KEY], 1.0, -0.5) self._src2 = gr.frequency_modulator_fc( self[WAVEFORM_FREQ_KEY] * 2 * math.pi / self[SAMP_RATE_KEY]) self._src = gr.multiply_const_cc(self[AMPLITUDE_KEY]) self.connect(self._src1, self._src2, self._src) else: raise RuntimeError("Unknown waveform type") self.connect(self._src, self._u) self.unlock() if self._verbose: print "Set baseband modulation to:", waveforms[type] if type == gr.GR_SIN_WAVE: print "Modulation frequency: %sHz" % (n2s( self[WAVEFORM_FREQ_KEY]), ) print "Initial phase:", self[WAVEFORM_OFFSET_KEY] elif type == "2tone": print "Tone 1: %sHz" % (n2s(self[WAVEFORM_FREQ_KEY]), ) print "Tone 2: %sHz" % (n2s(self[WAVEFORM2_FREQ_KEY]), ) elif type == "sweep": print "Sweeping across %sHz to %sHz" % (n2s( -self[WAVEFORM_FREQ_KEY] / 2.0), n2s(self[WAVEFORM_FREQ_KEY] / 2.0)) print "Sweep rate: %sHz" % (n2s(self[WAVEFORM2_FREQ_KEY]), ) print "TX amplitude:", self[AMPLITUDE_KEY]
def test_fff_000(self): N = 1000 # number of samples to use fs = 1000 # baseband sampling rate rrate = 1.123 # resampling rate nfilts = 32 freq = 100 signal = gr.sig_source_f(fs, gr.GR_SIN_WAVE, freq, 1) head = gr.head(gr.sizeof_float, N) pfb = filter.pfb_arb_resampler_fff(rrate, taps) snk = gr.vector_sink_f() self.tb.connect(signal, head, pfb, snk) self.tb.run() Ntest = 50 L = len(snk.data()) t = map(lambda x: float(x)/(fs*rrate), xrange(L)) phase = 0.53013 expected_data = map(lambda x: math.sin(2.*math.pi*freq*x+phase), t) dst_data = snk.data() self.assertFloatTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 3)
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block .__init__ (self, frame, panel, vbox, argv) fac_size = 256 # build our flow graph input_rate = 20.48e3 # Generate a complex sinusoid #src1 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 2e3, 1) src1 = gr.sig_source_c (input_rate, gr.GR_CONST_WAVE, 5.75e3, 1) # We add these throttle blocks so that this demo doesn't # suck down all the CPU available. Normally you wouldn't use these. thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate) sink1 = fac_sink_c (panel, title="Complex Data", fac_size=fac_size, sample_rate=input_rate, baseband_freq=100e3, ref_level=0, y_per_div=20) vbox.Add (sink1.win, 1, wx.EXPAND) self.connect (src1, thr1, sink1) #src2 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 2e3, 1) src2 = gr.sig_source_f (input_rate, gr.GR_CONST_WAVE, 5.75e3, 1) thr2 = gr.throttle(gr.sizeof_float, input_rate) sink2 = fac_sink_f (panel, title="Real Data", fac_size=fac_size*2, sample_rate=input_rate, baseband_freq=100e3, ref_level=0, y_per_div=20) vbox.Add (sink2.win, 1, wx.EXPAND) self.connect (src2, thr2, sink2)
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv) fft_size = 512 # build our flow graph input_rate = 20.000e3 # Generate a complex sinusoid self.src1 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 5.75e3, 1000) #src1 = gr.sig_source_c (input_rate, gr.GR_CONST_WAVE, 5.75e3, 1000) # We add these throttle blocks so that this demo doesn't # suck down all the CPU available. Normally you wouldn't use these. self.thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate) sink1 = waterfall_sink_c (panel, title="Complex Data", fft_size=fft_size, sample_rate=input_rate, baseband_freq=100e3) self.connect(self.src1, self.thr1, sink1) vbox.Add (sink1.win, 1, wx.EXPAND) # generate a real sinusoid self.src2 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 5.75e3, 1000) self.thr2 = gr.throttle(gr.sizeof_float, input_rate) sink2 = waterfall_sink_f (panel, title="Real Data", fft_size=fft_size, sample_rate=input_rate, baseband_freq=100e3) self.connect(self.src2, self.thr2, sink2) vbox.Add (sink2.win, 1, wx.EXPAND)
def __init__(self,ramp_slope, height_Offset, width_Offset): gr.hier_block2.__init__(self,"HierBlock",gr.io_signature(1,1,gr.sizeof_float), gr.io_signature(1,2,gr.sizeof_float)) #constant_block initialized self.constant_block = gr.sig_source_f(0,gr.GR_CONST_WAVE,0,0,1) #ramp_source block initialized self.ramp_source=gr_ramp_source.ramp() self.ramp_source.set_parameters(ramp_slope, height_Offset, width_Offset) self.connect(self,(self.constant_block,0),(self.ramp_source,0),self)
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) fft_size = 256 # build our flow graph input_rate = 2048.0e3 # Generate some noise noise = gr.noise_source_c(gr.GR_UNIFORM, 1.0 / 10) # Generate a complex sinusoid # src1 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 2e3, 1) src1 = gr.sig_source_c(input_rate, gr.GR_CONST_WAVE, 57.50e3, 1) # We add these throttle blocks so that this demo doesn't # suck down all the CPU available. Normally you wouldn't use these. thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate) sink1 = fft_sink_c( panel, title="Complex Data", fft_size=fft_size, sample_rate=input_rate, baseband_freq=100e3, ref_level=0, y_per_div=20, y_divs=10, ) vbox.Add(sink1.win, 1, wx.EXPAND) combine1 = gr.add_cc() self.connect(src1, (combine1, 0)) self.connect(noise, (combine1, 1)) self.connect(combine1, thr1, sink1) # src2 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 2e3, 1) src2 = gr.sig_source_f(input_rate, gr.GR_CONST_WAVE, 57.50e3, 1) thr2 = gr.throttle(gr.sizeof_float, input_rate) sink2 = fft_sink_f( panel, title="Real Data", fft_size=fft_size * 2, sample_rate=input_rate, baseband_freq=100e3, ref_level=0, y_per_div=20, y_divs=10, ) vbox.Add(sink2.win, 1, wx.EXPAND) combine2 = gr.add_ff() c2f2 = gr.complex_to_float() self.connect(src2, (combine2, 0)) self.connect(noise, c2f2, (combine2, 1)) self.connect(combine2, thr2, sink2)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="My First Block Fg") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.wxgui_numbersink2_0 = numbersink2.number_sink_f( self.GetWin(), unit="Units", minval=-100, maxval=100, factor=1.0, decimal_places=10, ref_level=0, sample_rate=samp_rate, number_rate=15, average=False, avg_alpha=None, label="Number Plot", peak_hold=False, show_gauge=True, ) self.Add(self.wxgui_numbersink2_0.win) self.my_first_python_block_0 = dt.my_first_python_block() self.gr_throttle_0 = gr.throttle(gr.sizeof_float * 1, samp_rate) self.const_source_x_0_0 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, -22) self.const_source_x_0 = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 5) ################################################## # Connections ################################################## self.connect((self.const_source_x_0, 0), (self.my_first_python_block_0, 0)) self.connect((self.const_source_x_0_0, 0), (self.my_first_python_block_0, 1)) self.connect((self.my_first_python_block_0, 0), (self.gr_throttle_0, 0)) self.connect((self.gr_throttle_0, 0), (self.wxgui_numbersink2_0, 0))
def __init__(self): gr.top_block.__init__(self) self._nsamples = 1000000 self._audio_rate = 8000 # Set up N channels with their own baseband and IF frequencies self._N = 5 chspacing = 16000 freq = [10, 20, 30, 40, 50] f_lo = [0, 1*chspacing, -1*chspacing, 2*chspacing, -2*chspacing] self._if_rate = 4*self._N*self._audio_rate # Create a signal source and frequency modulate it self.sum = gr.add_cc () for n in xrange(self._N): sig = gr.sig_source_f(self._audio_rate, gr.GR_SIN_WAVE, freq[n], 0.5) fm = fmtx(f_lo[n], self._audio_rate, self._if_rate) self.connect(sig, fm) self.connect(fm, (self.sum, n)) self.head = gr.head(gr.sizeof_gr_complex, self._nsamples) self.snk_tx = gr.vector_sink_c() self.channel = blks2.channel_model(0.1) self.connect(self.sum, self.head, self.channel, self.snk_tx) # Design the channlizer self._M = 10 bw = chspacing/2.0 t_bw = chspacing/10.0 self._chan_rate = self._if_rate / self._M self._taps = gr.firdes.low_pass_2(1, self._if_rate, bw, t_bw, attenuation_dB=100, window=gr.firdes.WIN_BLACKMAN_hARRIS) tpc = math.ceil(float(len(self._taps)) / float(self._M)) print "Number of taps: ", len(self._taps) print "Number of channels: ", self._M print "Taps per channel: ", tpc self.pfb = blks2.pfb_channelizer_ccf(self._M, self._taps) self.connect(self.channel, self.pfb) # Create a file sink for each of M output channels of the filter and connect it self.fmdet = list() self.squelch = list() self.snks = list() for i in xrange(self._M): self.fmdet.append(blks2.nbfm_rx(self._audio_rate, self._chan_rate)) self.squelch.append(blks2.standard_squelch(self._audio_rate*10)) self.snks.append(gr.vector_sink_f()) self.connect((self.pfb, i), self.fmdet[i], self.squelch[i], self.snks[i])
def __init__(self): gr.flow_graph.__init__(self) parser = OptionParser(option_class=eng_option) parser.add_option( "-T", "--tx-subdev-spec", type="subdev", default=None, help= "select USRP Tx side A or B (default=first one with a daughterboard)" ) parser.add_option("-c", "--cordic-freq", type="eng_float", default=434845200, help="set Tx cordic frequency to FREQ", metavar="FREQ") (options, args) = parser.parse_args() print "cordic_freq = %s" % (eng_notation.num_to_str( options.cordic_freq)) self.normal_gain = 8000 self.u = usrp.sink_s() dac_rate = self.u.dac_rate() self._freq = 1000 self._spb = 256 self._interp = int(128e6 / self._spb / self._freq) self.fs = 128e6 / self._interp print "Interpolation:", self._interp self.u.set_interp_rate(self._interp) # determine the daughterboard subdevice we're using if options.tx_subdev_spec is None: options.tx_subdev_spec = usrp.pick_tx_subdevice(self.u) self.u.set_mux( usrp.determine_tx_mux_value(self.u, options.tx_subdev_spec)) self.subdev = usrp.selected_subdev(self.u, options.tx_subdev_spec) print "Using TX d'board %s" % (self.subdev.side_and_name(), ) self.u.tune(self.subdev._which, self.subdev, options.cordic_freq) self.sin = gr.sig_source_f(self.fs, gr.GR_SIN_WAVE, self._freq, 1, 0) self.gain = gr.multiply_const_ff(self.normal_gain) self.ftos = gr.float_to_short() self.filesink = gr.file_sink(gr.sizeof_float, 'sin.dat') self.connect(self.sin, self.gain) self.connect(self.gain, self.ftos, self.u) #self.connect(self.gain, self.filesink) self.set_gain(self.subdev.gain_range()[1]) # set max Tx gain self.set_auto_tr(True) # enable Auto Transmit/Receive switching
def __init__(self): gr.top_block.__init__(self) Rs = 8000 f1 = 1000 f2 = 2000 fftsize = 2048 self.qapp = QtGui.QApplication(sys.argv) src1 = gr.sig_source_f(Rs, gr.GR_SIN_WAVE, f1, 0.1, 0) src2 = gr.sig_source_f(Rs, gr.GR_SIN_WAVE, f2, 0.1, 0) src = gr.add_ff() thr = gr.throttle(gr.sizeof_float, 100*fftsize) noise = gr.noise_source_f(gr.GR_GAUSSIAN, 0.001) add = gr.add_ff() self.snk1 = qtgui.sink_f(fftsize, gr.firdes.WIN_BLACKMAN_hARRIS, 0, Rs, "Float Signal Example", True, True, True, False) self.connect(src1, (src,0)) self.connect(src2, (src,1)) self.connect(src, thr, (add,0)) self.connect(noise, (add,1)) self.connect(add, self.snk1) self.ctrl_win = control_box() self.ctrl_win.attach_signal1(src1) self.ctrl_win.attach_signal2(src2) # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt4.QtGui.QWidget pyWin = sip.wrapinstance(pyQt, QtGui.QWidget) self.main_box = dialog_box(pyWin, self.ctrl_win) self.main_box.show()
def test_const_f (self): tb = self.tb expected_result = (1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5) src1 = gr.sig_source_f (1e6, gr.GR_CONST_WAVE, 0, 1.5) op = gr.head (gr.sizeof_float, 10) dst1 = gr.vector_sink_f () tb.connect (src1, op) tb.connect (op, dst1) tb.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_saw_f (self): tb = self.tb expected_result = (.5, .625, .75, .875, 0, .125, .25, .375, .5) src1 = gr.sig_source_f (8, gr.GR_SAW_WAVE, 1.0, 1.0) op = gr.head (gr.sizeof_float, 9) dst1 = gr.vector_sink_f () tb.connect (src1, op) tb.connect (op, dst1) tb.run () dst_data = dst1.data () self.assertFloatTuplesAlmostEqual (expected_result, dst_data, 5)
def __init__(self): gr.flow_graph.__init__(self) #build flow graph #create two sinusoidal sources with a sample rate # of 48000s/s and frequencies of 350 and 440 #amplitude of 0.1 src0 = gr.sig_source_f(48000, gr.GR_SIN_WAVE, 350, 0.1) src1 = gr.sig_source_f(48000, gr.GR_SIN_WAVE, 440, 0.1) #create a destination sink dst = audio.sink(48000) #connect each of the sources to the sink self.connect(src0, (dst, 0)) self.connect(src1, (dst, 1)) #puts 350 Hz into a data file fs = gr.file_sink(gr.sizeof_float, "audio.dat") self.connect(src0, fs)
def test_sqr_f (self): fg = self.fg expected_result = (0, 0, 0, 0, 1, 1, 1, 1, 0) src1 = gr.sig_source_f (8, gr.GR_SQR_WAVE, 1.0, 1.0) op = gr.head (gr.sizeof_float, 9) dst1 = gr.vector_sink_f () fg.connect (src1, op) fg.connect (op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_saw_f (self): fg = self.fg expected_result = (.5, .625, .75, .875, 0, .125, .25, .375, .5) src1 = gr.sig_source_f (8, gr.GR_SAW_WAVE, 1.0, 1.0) op = gr.head (gr.sizeof_float, 9) dst1 = gr.vector_sink_f () fg.connect (src1, op) fg.connect (op, dst1) fg.run () dst_data = dst1.data () self.assertFloatTuplesAlmostEqual (expected_result, dst_data, 5)
def test_const_f (self): fg = self.fg expected_result = (1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5) src1 = gr.sig_source_f (1e6, gr.GR_CONST_WAVE, 0, 1.5) op = gr.head (gr.sizeof_float, 10) dst1 = gr.vector_sink_f () fg.connect (src1, op) fg.connect (op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_sqr_f (self): tb = self.tb expected_result = (0, 0, 0, 0, 1, 1, 1, 1, 0) src1 = gr.sig_source_f (8, gr.GR_SQR_WAVE, 1.0, 1.0) op = gr.head (gr.sizeof_float, 9) dst1 = gr.vector_sink_f () tb.connect (src1, op) tb.connect (op, dst1) tb.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def __init__(self): gr.top_block.__init__(self) self._N = 200000 # number of samples to use self._fs = 9000 # initial sampling rate self._M = 9 # Number of channels to channelize # Create a set of taps for the PFB channelizer self._taps = gr.firdes.low_pass_2(1, self._fs, 500, 20, attenuation_dB=10, window=gr.firdes.WIN_BLACKMAN_hARRIS) # Calculate the number of taps per channel for our own information tpc = scipy.ceil(float(len(self._taps)) / float(self._M)) print "Number of taps: ", len(self._taps) print "Number of channels: ", self._M print "Taps per channel: ", tpc repeated = True if (repeated): self.vco_input = gr.sig_source_f(self._fs, gr.GR_SIN_WAVE, 0.25, 110) else: amp = 100 data = scipy.arange(0, amp, amp / float(self._N)) self.vco_input = gr.vector_source_f(data, False) # Build a VCO controlled by either the sinusoid or single chirp tone # Then convert this to a complex signal self.vco = gr.vco_f(self._fs, 225, 1) self.f2c = gr.float_to_complex() self.head = gr.head(gr.sizeof_gr_complex, self._N) # Construct the channelizer filter self.pfb = blks2.pfb_channelizer_ccf(self._M, self._taps) # Construct a vector sink for the input signal to the channelizer self.snk_i = gr.vector_sink_c() # Connect the blocks self.connect(self.vco_input, self.vco, self.f2c) self.connect(self.f2c, self.head, self.pfb) self.connect(self.f2c, self.snk_i) # Create a vector sink for each of M output channels of the filter and connect it self.snks = list() for i in xrange(self._M): self.snks.append(gr.vector_sink_c()) self.connect((self.pfb, i), self.snks[i])
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) fft_size = 256 # build our flow graph input_rate = 2048.0e3 #Generate some noise noise = gr.noise_source_c(gr.GR_UNIFORM, 1.0 / 10) # Generate a complex sinusoid #src1 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 2e3, 1) src1 = gr.sig_source_c(input_rate, gr.GR_CONST_WAVE, 57.50e3, 1) # We add these throttle blocks so that this demo doesn't # suck down all the CPU available. Normally you wouldn't use these. thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate) sink1 = fft_sink_c(panel, title="Complex Data", fft_size=fft_size, sample_rate=input_rate, baseband_freq=100e3, ref_level=0, y_per_div=20, y_divs=10) vbox.Add(sink1.win, 1, wx.EXPAND) combine1 = gr.add_cc() self.connect(src1, (combine1, 0)) self.connect(noise, (combine1, 1)) self.connect(combine1, thr1, sink1) #src2 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 2e3, 1) src2 = gr.sig_source_f(input_rate, gr.GR_CONST_WAVE, 57.50e3, 1) thr2 = gr.throttle(gr.sizeof_float, input_rate) sink2 = fft_sink_f(panel, title="Real Data", fft_size=fft_size * 2, sample_rate=input_rate, baseband_freq=100e3, ref_level=0, y_per_div=20, y_divs=10) vbox.Add(sink2.win, 1, wx.EXPAND) combine2 = gr.add_ff() c2f2 = gr.complex_to_float() self.connect(src2, (combine2, 0)) self.connect(noise, c2f2, (combine2, 1)) self.connect(combine2, thr2, sink2)
def test_cosine_f (self): tb = self.tb sqrt2 = math.sqrt(2) / 2 expected_result = (1, sqrt2, 0, -sqrt2, -1, -sqrt2, 0, sqrt2, 1) src1 = gr.sig_source_f (8, gr.GR_COS_WAVE, 1.0, 1.0) op = gr.head (gr.sizeof_float, 9) dst1 = gr.vector_sink_f () tb.connect (src1, op) tb.connect (op, dst1) tb.run () dst_data = dst1.data () self.assertFloatTuplesAlmostEqual (expected_result, dst_data, 5)
def __init__(self, step_size, H_Off, W_Off): gr.hier_block2.__init__(self, "HierBlock", gr.io_signature(1, 1, gr.sizeof_float), gr.io_signature(1, 2, gr.sizeof_float)) # constant_block initialized self.constant_block = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 1) # step_source block initialized self.step_source = gr_step_source.step() self.step_source.set_parameters(step_size, H_Off, W_Off) self.connect(self, (self.constant_block, 0), (self.step_source, 0), self)
def __init__(self, ramp_slope, height_Offset, width_Offset): gr.hier_block2.__init__(self, "HierBlock", gr.io_signature(1, 1, gr.sizeof_float), gr.io_signature(1, 2, gr.sizeof_float)) #constant_block initialized self.constant_block = gr.sig_source_f(0, gr.GR_CONST_WAVE, 0, 0, 1) #ramp_source block initialized self.ramp_source = gr_ramp_source.ramp() self.ramp_source.set_parameters(ramp_slope, height_Offset, width_Offset) self.connect(self, (self.constant_block, 0), (self.ramp_source, 0), self)
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) # build our flow graph input_rate = 20.48e3 src2 = gr.sig_source_f(input_rate, gr.GR_SIN_WAVE, 2e3, 1) #src2 = gr.sig_source_f (input_rate, gr.GR_CONST_WAVE, 5.75e3, 1) thr2 = gr.throttle(gr.sizeof_float, input_rate) sink2 = histo_sink_f(panel, title="Data", num_bins=31, frame_size=1000) vbox.Add(sink2.win, 1, wx.EXPAND) self.connect(src2, thr2, sink2)
def __init__(self, seconds,history,output_multiple): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) parser.add_option("-O", "--audio-output", type="string", default="", help="pcm output device name. E.g., hw:0,0 or /dev/dsp") parser.add_option("-r", "--sample-rate", type="eng_float", default=48000, help="set sample rate to RATE (48000)") (options, args) = parser.parse_args () if len(args) != 0: parser.print_help() raise SystemExit, 1 sample_rate = int(options.sample_rate) ampl = 0.1 src0 = gr.sig_source_f (sample_rate, gr.GR_SIN_WAVE, 350, ampl) nsamples=int(sample_rate * seconds) #1 seconds # gr.test (const std::string &name=std::string("gr_test"), # int min_inputs=1, int max_inputs=1, unsigned int sizeof_input_item=1, # int min_outputs=1, int max_outputs=1, unsigned int sizeof_output_item=1, # unsigned int history=1,unsigned int output_multiple=1,double relative_rate=1.0, # bool fixed_rate=true,gr_consume_type_t cons_type=CONSUME_NOUTPUT_ITEMS, gr_produce_type_t prod_type=PRODUCE_NOUTPUT_ITEMS); name="gr_test" min_inputs=1 max_inputs=1 sizeof_input_item=gr.sizeof_float min_outputs=1 max_outputs=1 sizeof_output_item=gr.sizeof_float #history=1 # problems start at 8150 #output_multiple=1 #problems start at 8000 in combination with large history relative_rate=1.0 fixed_rate=True consume_type=gr.CONSUME_NOUTPUT_ITEMS produce_type=gr.PRODUCE_NOUTPUT_ITEMS test = gr.test(name, min_inputs,max_inputs,sizeof_input_item, min_outputs,max_outputs,sizeof_output_item, history,output_multiple,relative_rate, fixed_rate, consume_type,produce_type) #test = gr.test("gr_test",1,1,gr.sizeof_float, # 1,1,gr.sizeof_float, # 1,1,1.0, # True, gr.CONSUME_NOUTPUT_ITEMS,gr.PRODUCE_NOUTPUT_ITEMS) #unsigned int history=1,unsigned int output_multiple=1,double relative_rate=1.0, #bool fixed_rate=false dst = audio.sink (sample_rate, options.audio_output) head= gr.head(gr.sizeof_float, nsamples) self.connect (src0,test,head,(dst, 0))
def key_factory(index): print "FACTORY CALLED index = %d"%(index); r = es.es_pyhandler(); src_L = gr.sig_source_f( 48e3, gr.GR_SIN_WAVE, 1440.0, 1.0, 0 ); src_R = gr.sig_source_f( 48e3, gr.GR_SIN_WAVE, 480.0, 1.0, 0 ); head_L = gr.head( gr.sizeof_float, evt_len ); head_R = gr.head( gr.sizeof_float, evt_len ); r.sink = es.vector_sink([gr.sizeof_float, gr.sizeof_float]); tb = gr.top_block(); tb.connect( (src_L,0), (head_L,0), (r.sink,0) ); tb.connect( (src_R,0), (head_R,0), (r.sink,1) ); # store blocks where we can get to them blocks = {}; blocks["src_L"] = src_L; blocks["src_R"] = src_R; blocks["head_L"] = head_L; blocks["head_R"] = head_R; r.set_pyb2(blocks); r.tb = tb.to_top_block(); return r;