Re: [Discuss-gnuradio] GNURadio Help

[CEL]

Ivan,

the E310 is a very special USRP as it not only requires you to
understand radio, software, digital signal processing and development,
but also embedded hardware development and efficiently also FPGA
design. Are you *sure* you want to start with that? Without meaning to
cause any offense, this is a bigger project than you realize that
you're about to take on.
None of the things I explained before will work, because the E310's CPU
is simply too weak to get 30 MS/s out of the digital logic, let alone
do any processing on them.

This, by the way also answers John's question: Ivan's got to do the
processing in the radio, as the host computer is the E310's ARM CPU and
that can't even handle the memory bandwidth of 30 MS/s at 32 bit per
sample, but needs it to be broken down to a much smaller amount of
data. Also, since the E310 is one of the USRPs that cannot do tuned
commands, throwing away data in the FPGA before it even reaches the FFT
(which also has to happen in the FPGA) is kind of a necessity.

So, if you don't want to dive right into FPGA developement (and I
strongly recommend you don't!), you'll need to reduce your expectations
to doing maybe 1 MHz at once, because that's what your CPU will be able
to process in software with an FFT of any significant size.

So, the closest to what you want exists in the shape of RFNoC Fosphor
architecture: It sends FFT'ed, magnitude-squared, logarithmized, even
practically color-mapped values and thus can achieve good bandwidth
even on an E310. Adding the tuning and frequency coordination logic
would, on the other hand, really require a lot of work in the FPGA, and
it'll have nothing to do with GNU Radio.

If you want my personal opinion: Start with a different device.
Learning about GNU Radio, DSP, SDR is hard enough. Don't add FPGAs,
embedded devices and mandatory RFNoC to it for a start.

Best regards,
Marcus

On Wed, 2018-06-13 at 09:11 -0600, John Medrano wrote:
> This is much more doable. 
> 
> May I ask why you want to buffer all the data in the radio?
> 
> On Wed, Jun 13, 2018 at 9:06 AM, Ivan Zahartchuk <address@hidden> 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 <address@hidden>:
> > > 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 <address@hidden> wrote:
> > > > In the future, I would also like to use the RFNoC
> > > > 
> > > > 2018-06-13 17:42 GMT+03:00 Ivan Zahartchuk <address@hidden>:
> > > > > 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) <address@hidden>:
> > > > > > 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_center_freq(self.start_freq+self.samp_rate*i)
> > > > > > >             
> > > > > > > data=np.array(self.uhd_usrp_source_0.finite_acquisition(8192))
> > > > > > >         output_items[0][:] = input_items[0] * self.example_param
> > > > > > >         return len(output_items[0])
> > > > > > > _______________________________________________
> > > > > > > Discuss-gnuradio mailing list
> > > > > > > address@hidden
> > > > > > > https://lists.gnu.org/mailman/listinfo/discuss-gnuradio
> > > > 
> > > > 
> > > > _______________________________________________
> > > > Discuss-gnuradio mailing list
> > > > address@hidden
> > > > https://lists.gnu.org/mailman/listinfo/discuss-gnuradio
> > > > 
> 
>

smime.p7s
Description: S/MIME cryptographic signature