Hello,
I see you are using an E310, now this seems to make a bit more sense as to
what you are trying to do.
Although you can use RFNOC to increase the processor ability to do FFT
function, it is actually not needed for initial testing. In GNU radio,
there are many ways to enhance your design, but there is a simple approach
that will work.
RADIO->STREAM TO VECTOR->FFT->CUSTOM BLOCK
The FFT block will pass data to your custom blocks of X data points. Where
X is your FFT Size.
Your custom block would then store 1 block of X data points, and then set a
flag to indicate that it has data. So your custom block should have
functions to check flag and retrieve data.
The rest of the work you can do in Python.
while 1:
tb.start()
time.sleep(1.0)
tb.stop()
tb.wait()
tb.store_data()
tb.change_freq()
tb.store_data() will check your custom block to see if data there, and if
yes will store it to file in whatever format you want. tb.change_freq()
will basically change the frequency of radio component to new frequency
setting. You would need to add code in Python that transmits to host when
all data blocks have been collected.
One big problem with E310 though, I doubt if you are going to be able to
process with a sample rate of 30 MHz. You may have to go down to as low as
5 MHz. The only approach that would increase band width would to move your
custom block and FFT back into FPGA with RFNOC. But this is very complex
endeavor.
On Wed, Jun 13, 2018 at 9:06 AM, Ivan Zahartchuk <adray0...@gmail.com>
wrote:
> I want to process not 6GHz but 30 MHz at a time. Ie I read 30 MHz at a
> frequency of 400 MHz (for example) then I do 30 MHz FFT and write them to
> the buffer. And so up to 6GHz. Then when the buffer is full, I transfer
> the data to the host machine (I use the USRP E310 board) to display the
> data.
> In fact, it should be such a broadband spectrum analyzer not in real time.
>
> 2018-06-13 17:57 GMT+03:00 John Medrano <john.d.medr...@gmail.com>:
>
>> Hello.
>>
>> If I understand what you are saying correctly, you would like to process
>> wide band data. And you mention 70 MHz to 6 GHz.
>>
>> Even with RFNOC there is a limitation on the amount of data you can
>> process simultaneously, and that is about 200 MHz. There is no way possible
>> to simultaneously process a 6GHz band with one host and radio. You would
>> need an array of radios.
>>
>> Please provide more details on design requirements, it hard to understand
>> what you are trying to accomplish.
>>
>> On Wed, Jun 13, 2018 at 8:46 AM, Ivan Zahartchuk <adray0...@gmail.com>
>> wrote:
>>
>>> In the future, I would also like to use the RFNoC
>>>
>>> 2018-06-13 17:42 GMT+03:00 Ivan Zahartchuk <adray0...@gmail.com>:
>>>
>>>> I need to rebuild the frequency, do fft and then transfer the whole
>>>> array from 70 to 6GHz to the host machine. I do not quite imagine how
>>>> you can do this with standard blocks in gnuradio.
>>>>
>>>>
>>>> 2018-06-13 17:32 GMT+03:00 Müller, Marcus (CEL) <muel...@kit.edu>:
>>>>
>>>>> Dear Ivan,
>>>>>
>>>>> you don't pass data to a block yourself.
>>>>>
>>>>> You write a block that does a clearly-limited signal processing job,
>>>>> and use GNU Radio to connect that to other blocks:
>>>>>
>>>>> https://tutorials.gnuradio.org
>>>>>
>>>>> In your case, instantiating a USRP source in your block makes
>>>>> absolutely no sense, for example. You'd build a flow graph containing
>>>>> the USRP source, and your custom-written block, and you'd connect these
>>>>> two.
>>>>>
>>>>> It's sadly not really clear what you want to achieve, so I'm afraid I'm
>>>>> not able to help you here.
>>>>>
>>>>> Generally, GNU Radio pretty much takes the idea of "draw a block
>>>>> diagram of what you want to achieve with your signal processing", and
>>>>> directly translates it to "using existing blocks and writing new ones,
>>>>> and letting GNU Radio take care of how the data gets around".
>>>>>
>>>>> Also, wideband signal processing and implementing a sync_block in
>>>>> Python... do not work well together.
>>>>>
>>>>> So, I think you might really be a bit confused about the architecture
>>>>> of GNU Radio – I really hope the tutorials explain that better than I
>>>>> could.
>>>>>
>>>>> Best regards,
>>>>> Marcus
>>>>>
>>>>> On Wed, 2018-06-13 at 17:16 +0300, Ivan Zahartchuk wrote:
>>>>> > Hello. I'm trying to write a block in gnuradio for broadband
>>>>> reception.
>>>>> > The main problem at the moment is to transfer data to the fft
>>>>> block.
>>>>> > I'm new to python and so it's hard for me to figure this out.import
>>>>> numpy as np
>>>>> >
>>>>> > I need an array of data to pass to the gnuradio.fft.fft.vcc block
>>>>> >
>>>>> > from gnuradio import gr
>>>>> > from gnuradio import uhd
>>>>> > from gnuradio import fft
>>>>> >
>>>>> > class blk(gr.sync_block): # other base classes are basic_block,
>>>>> decim_block, interp_block
>>>>> > """Embedded Python Block example - a simple multiply const"""
>>>>> >
>>>>> > def __init__(self,
>>>>> > gain=1.0,start_freq=70e6,stop_freq=6000e6,samp_rate=30e6):
>>>>> # only default arguments here
>>>>> > """arguments to this function show up as parameters in GRC"""
>>>>> > gr.sync_block.__init__(
>>>>> > self,
>>>>> > name='Python Block', # will show up in GRC
>>>>> > in_sig=None,
>>>>> > out_sig=[np.complex64,np.complex64]
>>>>> > )
>>>>> > # if an attribute with the same name as a parameter is found,
>>>>> > # a callback is registered (properties work, too).
>>>>> > self.gain = gain
>>>>> > self.start_freq=start_freq
>>>>> > self.stop_freq=stop_freq
>>>>> > self.samp_rate=samp_rate
>>>>> > self.uhd_usrp_source_0 = uhd.usrp_source(",".join(("", "")),
>>>>> > uhd.stream_args(
>>>>> >
>>>>> cpu_format="fc32",
>>>>> >
>>>>> otw_format="sc16",
>>>>> >
>>>>> chanels=range(1),
>>>>> > ),
>>>>> > )
>>>>> >
>>>>> >
>>>>> > self.uhd_usrp_source_0.set_clock_rate(30e6, uhd.ALL_MBOARDS)
>>>>> > self.uhd_usrp_source_0.set_samp_rate(self.samp_rate)
>>>>> > self.uhd_usrp_source_0.set_gain(self.gain, 0)
>>>>> > self.uhd_usrp_source_0.set_antenna("RX2", 0)
>>>>> > self.uhd_usrp_source_0.set_bandwidth(30e6, 0)
>>>>> > self.range_freq=(self.stop_freq-self.start_freq)/self.samp_
>>>>> rate
>>>>> >
>>>>> > def work(self, input_items, output_items):
>>>>> > """example: multiply with constant"""
>>>>> > for i in np.range(self.range_freq):
>>>>> > self.uhd_usrp_source_0.set_ce
>>>>> nter_freq(self.start_freq+self.samp_rate*i)
>>>>> > data=np.array(self.uhd_usrp_s
>>>>> ource_0.finite_acquisition(8192))
>>>>> > output_items[0][:] = input_items[0] * self.example_param
>>>>> > return len(output_items[0])
>>>>> > _______________________________________________
>>>>> > Discuss-gnuradio mailing list
>>>>> > Discuss-gnuradio@gnu.org
>>>>> > https://lists.gnu.org/mailman/listinfo/discuss-gnuradio
>>>>
>>>>
>>>>
>>>
>>> _______________________________________________
>>> Discuss-gnuradio mailing list
>>> Discuss-gnuradio@gnu.org
>>> https://lists.gnu.org/mailman/listinfo/discuss-gnuradio
>>>
>>>
>>
>
_______________________________________________
Discuss-gnuradio mailing list
Discuss-gnuradio@gnu.org
https://lists.gnu.org/mailman/listinfo/discuss-gnuradio
