def test_add_f32(self): tb = gr.flowgraph() input_data = list(range(1000)) expected_output = [2 * x for x in input_data] src0 = blocks.vector_source_f(input_data, False) src1 = blocks.vector_source_f(input_data, False) adder = add_2_f32_1_f32() copy_blks = [] nblocks = 1 bufsize = 1024 * 1024 tb.connect((src0, 0), (adder, 0)).set_custom_buffer( gr.buffer_cuda_sm_properties.make( gr.buffer_cuda_sm_type.H2D).set_min_buffer_size(bufsize)) tb.connect((src1, 0), (adder, 1)).set_custom_buffer( gr.buffer_cuda_sm_properties.make( gr.buffer_cuda_sm_type.H2D).set_min_buffer_size(bufsize)) last_blk = (adder, 0) for ii in range(nblocks): copy_blks.append(copy_f32()) tb.connect(last_blk, (copy_blks[ii], 0)).set_custom_buffer( gr.buffer_cuda_sm_properties.make( gr.buffer_cuda_sm_type.D2D).set_min_buffer_size(bufsize)) last_blk = (copy_blks[ii], 0) sink = blocks.vector_sink_f() tb.connect(last_blk, (sink, 0)).set_custom_buffer( gr.buffer_cuda_sm_properties.make( gr.buffer_cuda_sm_type.D2H).set_min_buffer_size(bufsize)) # tb.connect(adder, sink).set_custom_buffer(gr.buffer_cuda_sm_properties.make(gr.buffer_cuda_sm_type.D2H)) tb.run() self.assertEqual(sink.data(), expected_output)
def test_optional_absent(self): tb = gr.flowgraph() src0 = blocks.vector_source_f([1, 3, 5, 7, 9], False) src1 = blocks.vector_source_f([0, 2, 4, 6, 8], False) adder = add_optional() sink = blocks.vector_sink_f() tb.connect((src0, 0), (adder, 0)) tb.connect((src1, 0), (adder, 1)) tb.connect(adder, sink) tb.run() self.assertEqual(sink.data(), [1, 5, 9, 13, 17])
def setUp(self): self.tb = gr.flowgraph() self.freqs = [110., -513., 203., -230, 121] # Number of channels to channelize. self.M = len(self.freqs) # Number of samples to use. self.N = 1000 # Baseband sampling rate. self.fs = 5000 # Input samp rate to channelizer. self.ifs = self.M * self.fs self.taps = filter.firdes.low_pass_2( 1, self.ifs, self.fs / 2, self.fs / 10, attenuation_dB=80, window=fft.window.WIN_BLACKMAN_hARRIS) self.Ntest = 50
def setUp(self): self.tb = gr.flowgraph() self.rt = gr.runtime()
def flowgraph_create(self, **kwargs): self.fgs[kwargs['fg_name']] = gr.flowgraph(kwargs['fg_name']) # self.fgs[fg_name] = gr.flowgraph(fg_name) return {'status': 0}
def setUp(self): os.environ['GR_CONF_CONTROLPORT_ON'] = 'False' self.tb = gr.flowgraph() self.rt = gr.runtime()
from gnuradio.pyqtgraph.numpy import * import threading, time app = pg.mkQApp('DockArea Example') win = QtGui.QMainWindow() area = DockArea() win.setCentralWidget(area) win.resize(1000,500) win.setWindowTitle('pyqtgraph example: dockarea') samp_rate = 2000000 freq = 751000000 gain = 40 fg = gr.flowgraph() src = soapy.hackrf_source_c(samp_rate, freq, gain, vga=30.0, amp=True) # src = analog.sig_source_f(samp_rate, analog.waveform_t.cos, 12, 1.0) # snk = pg_plot_widget_f(100000, 'hello world') snk = pg_time_sink_c('hello world', 100000, 1) # snk2 = pg_time_sink_f('hello world 2', 100000) fg.connect(src, 0, snk, 0) d1 = Dock('a') area.addDock(d1,'top') d1.addWidget(snk.widget()) d2 = Dock('console') namespace = {'pg': pg, 'src': src } c = pyqtgraph.console.ConsoleWidget(namespace=namespace)
def setUp(self): random.seed(0) self.tb = gr.flowgraph()
# An example of distributing a flowgraph across remote nodes # These nodes could be containerized and/or live on remote hosts nsamples = 1000 # input_data = [x%256 for x in list(range(nsamples))] input_data = list(range(nsamples)) # Blocks are created locally, but will be replicated on the remote host src = blocks.vector_source_f(input_data, False) cp1 = streamops.copy() mc = math.multiply_const_ff(1.0) cp2 = streamops.copy() snk = blocks.vector_sink_f() fg1 = gr.flowgraph("FG On Local Host") fg1.connect([src, cp1, mc, cp2, snk]) with distributed.runtime( os.path.join(os.path.dirname(__file__), 'test_config.yml')) as rt1: # There are 2 remote hosts defined in the config yml # We assign groups of blocks where we want them to go rt1.assign_blocks("newsched1", [src, cp1, mc]) rt1.assign_blocks("newsched2", [cp2, snk]) rt1.initialize(fg1) # These calls on the local block are serialized to the remote block # This in effect means the local blocks are acting as proxy blocks mc.set_k(2.0) print(mc.k())