Good morning. Thanks for your answers, I fixed the record in the data
array. But
it did not help me. But I noticed that everything works for me when I add a
cycle
while samps:
samps = self.streamer_rx.recv (self.recv_buff,
self.metadata_rx)
after
self.stream_cmd = lib.types.stream_cmd (lib.types.stream_mode.stop_cont)
self.streamer_rx.issue_stream_cmd (self.stream_cmd).
I don’t fully understand why this cycle after closing reads and besides it
very much slows down the work of the program, which for me is a critical
moment.
def test_reciev_2(self, freq, bandwich):
complex_buffs = np.empty((len([0]), self.samples * len(freq)))
buffs = np.empty((len([0]), self.samples * len(freq)))
result = np.empty((len([0]), self.samples), dtype=np.complex64)
for i, freqq in enumerate(freq):
recv_samps = 0
# self.usrp.set_rx_rate(bandwich[i])
k = uhd.types.TuneRequest(freqq)
# k.args(uhd.types.device_addr("mode_n=integer"))
self.usrp.set_rx_freq(k)
self.stream_cmd = uhd.types.StreamCMD(uhd.types.StreamMode.start_cont)
self.stream_cmd.stream_now = True
self.streamer_rx.issue_stream_cmd(self.stream_cmd)
while self.usrp.get_rx_sensor("lo_locked").to_bool() != True:
continue
samps = np.array([], dtype=np.complex64)
while recv_samps < self.samples:
samps = self.streamer_rx.recv(self.recv_buff, self.metadata_rx)
if self.metadata_rx.error_code !=
lib.types.rx_metadata_error_code.none:
print(self.metadata_rx.strerror())
if samps:
real_samps = min(self.samples - recv_samps, samps)
result[:, recv_samps:recv_samps + real_samps] =
self.recv_buff[:, 0:real_samps]
recv_samps += real_samps
# print (self.usrp.get_rx_sensor('rssi'))
# print(self.streamer_rx.get_max_num_samps())
# self.stream_cmd.time_spec = lib.types.time_spec(0)
self.stream_cmd = lib.types.stream_cmd(lib.types.stream_mode.stop_cont)
self.streamer_rx.issue_stream_cmd(self.stream_cmd)
while samps:
samps = self.streamer_rx.recv(self.recv_buff, self.metadata_rx)
#complex_buffs = np.append(complex_buffs, result).ravel()
# correct_result=result
#correct_result_1 = result - (np.mean(result.real) +
np.mean(result.imag) * 1j)
# correct_result.real=result.real-np.mean(result.real)
# correct_result.imag = result.imag - np.mean(result.imag)
PSD = self.fft_test(result)
# PSD[8188:8202]=np.mean(PSD[8180:8188])
buffs[:, i * value.samples:value.samples * i + value.samples]
= PSD[:, 0:value.samples]
return complex_buffs, buffs.ravel()
вс, 12 мая 2019 г. в 02:35, Marcus Müller <marcus.muel...@ettus.com>:
> Ah, I see you think that this burst can't be too hard on your computer,
> because it arrives "at once"? That's not the case.
> On Sun, 2019-05-12 at 01:18 +0200, Marcus Müller wrote:
> > Um, sorry, I don't understand your sentence. Of course we have to
> > care
> > about these samples. Otherwise, we get an overflow. That is literally
> > what overflow means: Samples not getting received by the program
> > using
> > UHD in time before a buffer overflows.
> >
> > On Sat, 2019-05-11 at 22:29 +0300, Ivan Zahartchuk wrote:
> > > No, I meant that all system performance is enabled only when we
> > > make
> > > a request and not all the time. And we no longer care what we do
> > > next
> > > with these samples, they are just an array and the board does not
> > > require constant reading.
> > >
> > > вс, 12 мая 2019 г. в 01:03, Marcus Müller <marcus.muel...@ettus.com
> > > >:
> > > > I'm not quite sure how you come to the conclusion that we
> > > > wouldn't
> > > > be
> > > > tied to system performance in that case: that number of samples
> > > > still
> > > > needs to be received by the software running on the computer.
> > > >
> > > > Best regards,
> > > > Marcus
> > > >
> > > > On Sat, 2019-05-11 at 20:39 +0300, Ivan Zahartchuk wrote:
> > > > > Thanks for the help. I will try to fix everything tomorrow and
> > > > see
> > > > > the result. But tell me, maybe I don’t fully understand how
> > > > > num_sams_and_done works. If I understand correctly, this method
> > > > does
> > > > > not send a continuous stream of data but simply gives a certain
> > > > > number of samples upon request. And in this case, we are not
> > > > > tied
> > > > to
> > > > > system performance. Maybe I do not understand this. Could you
> > > > clarify
> > > > > this?
> > > > >
> > > > > сб, 11 мая 2019 г. в 23:19, Marcus Müller <
> > > > marcus.muel...@ettus.com>:
> > > > > > Dear Ivan,
> > > > > >
> > > > > > On Sat, 2019-05-11 at 20:00 +0300, Ivan Zahartchuk wrote:
> > > > > > > Sorry I did not specify. When working with the start_cont
> > > > mode
> > > > > > with a
> > > > > > > frequency of more than 5 MHz, I have an overflow error.
> > > > > >
> > > > > > Which probably happens due to the inefficient way you handle
> > > > the
> > > > > > data;
> > > > > > your program simply is too slow.
> > > > > >
> > > > > > > That leads to a chaotic change in the spectrum. I agree
> > > > > > > about
> > > > the
> > > > > > > wrong allocation of memory, but I created my own data array
> > > > and
> > > > > > ran
> > > > > > > it through the whole chain of changes and additions and had
> > > > what
> > > > > > I
> > > > > > > expected at the output.
> > > > > >
> > > > > > Huh? When using offline data, your computationally load
> > > > > > doesn't
> > > > > > matter;
> > > > > > I'm not sure I'm understanding you correctly here!
> > > > > >
> > > > > > > Moreover, the data array was much more than what I get from
> > > > the
> > > > > > > board. In this regard, I decided that the matter is in the
> > > > > > reading
> > > > > > > from the board.
> > > > > >
> > > > > > I'll allow myself to doubt that: Again, the fact that your
> > > > > > data
> > > > > > array
> > > > > > runs through smoothly is no indication for your software
> > > > > > being
> > > > fast
> > > > > > enough to keep up with the torrent of samples UHD will give
> > > > you!
> > > > > > When
> > > > > > it doesn't keep up, you see exactly what you're describing:
> > > > > > UHD
> > > > > > reporting overflows due to your software not fetching samples
> > > > fast
> > > > > > enough. Overflows aren't UHD bugs, they are problems in the
> > > > > > way
> > > > you
> > > > > > use
> > > > > > UHD!
> > > > > >
> > > > > > > I have seen examples, but start_cont mode is used there
> > > > > > > and
> > > > > > there
> > > > > > > are not so many frequency adjustments. Therefore, I decided
> > > > to
> > > > > > use
> > > > > > > the num_sams_and_done mode, but there is also a problem
> > > > > > > with
> > > > it
> > > > > > which
> > > > > > > is described in the previous message. If you have more
> > > > > > suggestions, I
> > > > > > > will be very grateful to you.
> > > > > >
> > > > > > Well, exactly what I wrote in my previous mail: you need to
> > > > make
> > > > > > your
> > > > > > software fast enough. Preallocate the buffer; don't append to
> > > > its
> > > > > > end.
> > > > > >
> > > > > > Aside from that, do some profiling. Under linux, `perf top
> > > > > > -ag
> > > > > > python
> > > > > > yourscript.py` is your friend to figure out where your
> > > > > > program
> > > > > > spends
> > > > > > its CPU cycles.
> > > > > >
> > > > > > Best regards,
> > > > > > Marcus
> > > > > >
> > > > > > > сб, 11 мая 2019 г. в 22:27, Marcus Müller <
> > > > > > marcus.muel...@ettus.com>:
> > > > > > > > Dear Ivan,
> > > > > > > >
> > > > > > > > it's not clear what you've modified. I'm not aware of any
> > > > UHD
> > > > > > > > function
> > > > > > > > that restricts any frequency to 5 MHz.
> > > > > > > > Could you elaborate on which code you're basing this on?
> > > > > > > >
> > > > > > > > Also, while I really like the Python interface, if you're
> > > > > > really
> > > > > > > > after
> > > > > > > > high-rate sampling, it might simply not be the optimal
> > > > thing to
> > > > > > > > use:
> > > > > > > > You'd have to be very careful in Pythonland to not run
> > > > > > > > into
> > > > > > > > performance
> > > > > > > > problems once you've gotten the samples from UHD:
> > > > > > > >
> > > > > > > >
> > > > complex_buffs=np.append(complex_buffs,result).ravel()
> > > > > > > > A very bad idea. You're constantly re-allocating buffers
> > > > here.
> > > > > > > > Don't do
> > > > > > > > that. No matter in which programming language you'd do
> > > > this,
> > > > > > you'd
> > > > > > > > make
> > > > > > > > sure that the buffer is large enough for your data
> > > > collection
> > > > > > to
> > > > > > > > begin
> > > > > > > > with and then tell the UHD library to fill the
> > > > > > > > appropriate
> > > > part
> > > > > > in
> > > > > > > > that
> > > > > > > > buffer to avoid a) having to ask for a larger buffer
> > > > regularly
> > > > > > and
> > > > > > > > b)
> > > > > > > > avoid copying data.
> > > > > > > > Asking for an appended version of your last buffer means
> > > > that
> > > > > > > > something
> > > > > > > > has to allocate a larger buffer – which comes at very
> > > > > > > > large
> > > > > > cost!
> > > > > > > > Best regards,
> > > > > > > > Marcus
> > > > > > > >
> > > > > > > > On Sat, 2019-05-11 at 21:31 +0300, Ivan Zahartchuk via
> > > > USRP-
> > > > > > users
> > > > > > > > wrote:
> > > > > > > > > Hello. My task is to make a broadband spectrum analyzer
> > > > on
> > > > > > the
> > > > > > > > usrp
> > > > > > > > > b200 board. For this, the standard functions for
> > > > > > > > > reading
> > > > > > samples
> > > > > > > > in
> > > > > > > > > python are not suitable for me. Therefore, I edited
> > > > > > > > > them.
> > > > > > When
> > > > > > > > > reading samples using the start_con method, I cannot
> > > > specify
> > > > > > a
> > > > > > > > band
> > > > > > > > > greater than 5 MHz. Therefore, I use the
> > > > num_sams_and_done
> > > > > > > > method.
> > > > > > > > > But I have problems with him. The fact is that my
> > > > frequency
> > > > > > which
> > > > > > > > I
> > > > > > > > > know appears in the wrong place. For example, I
> > > > > > > > > generate
> > > > a
> > > > > > > > frequency
> > > > > > > > > of 910 MHz and it appears at 930 MHz (with a bandwidth
> > > > > > > > > of
> > > > 20
> > > > > > > > MHz). I
> > > > > > > > > can not understand what caused it. Here are my reading
> > > > > > functions
> > > > > > > > in
> > > > > > > > > two ways. I would be extremely grateful for the help.
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > def test_reciev(self,freq,bandwich):
> > > > > > > > > complex_buffs=np.array([])
> > > > > > > > > buffs = np.array([])
> > > > > > > > > result = np.empty((len([0]), self.samples),
> > > > > > > > dtype=np.complex64)
> > > > > > > > > for i, freqq in enumerate(freq):
> > > > > > > > >
> > > > > > > > > recv_samps = 0
> > > > > > > > > #self.usrp.set_rx_rate(bandwich[i])
> > > > > > > > > k=uhd.types.TuneRequest(freqq)
> > > > > > > > > #k.args(uhd.types.device_addr("mode_n=integer")
> > > > > > > > > )
> > > > > > > > > self.usrp.set_rx_freq(k)
> > > > > > > > > self.stream_cmd =
> > > > > > > > > uhd.types.StreamCMD(uhd.types.StreamMode.start_cont)
> > > > > > > > > self.stream_cmd.stream_now = True
> > > > > > > > >
> > > > self.streamer_rx.issue_stream_cmd(self.stream_cmd)
> > > > > > > > > while
> > > > self.usrp.get_rx_sensor("lo_locked").to_bool()
> > > > > > !=
> > > > > > > > True:
> > > > > > > > > continue
> > > > > > > > >
> > > > > > > > > samps = np.array([], dtype=np.complex64)
> > > > > > > > > while recv_samps < self.samples:
> > > > > > > > >
> > > > > > > > > samps =
> > > > > > > > > self.streamer_rx.recv(self.recv_buff,
> > > > > > > > > self.metadata_rx)
> > > > > > > > > if self.metadata_rx.error_code !=
> > > > > > > > > lib.types.rx_metadata_error_code.none:
> > > > > > > > > print(self.metadata_rx.strerror())
> > > > > > > > > if samps:
> > > > > > > > > real_samps = min(self.samples -
> > > > recv_samps,
> > > > > > > > samps)
> > > > > > > > > result[:, recv_samps:recv_samps +
> > > > real_samps]
> > > > > > =
> > > > > > > > > self.recv_buff[:, 0:real_samps]
> > > > > > > > > recv_samps += real_samps
> > > > > > > > > #print (self.usrp.get_rx_sensor('rssi'))
> > > > > > > > > #print(self.streamer_rx.get_max_num_samps())
> > > > > > > > > #while samps:
> > > > > > > > > # samps =
> > > > self.streamer_rx.recv(self.recv_buff,
> > > > > > > > > self.metadata_rx)
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > #self.stream_cmd.time_spec =
> > > > lib.types.time_spec(0)
> > > > > > > > > self.stream_cmd =
> > > > > > > > > lib.types.stream_cmd(lib.types.stream_mode.stop_cont)
> > > > > > > > >
> > > > self.streamer_rx.issue_stream_cmd(self.stream_cmd)
> > > > > > > > >
> > > > complex_buffs=np.append(complex_buffs,result).ravel()
> > > > > > > > > #correct_result=result
> > > > > > > > > correct_result_1=result-
> > > > > > > > > (np.mean(result.real)+np.mean(result.imag)*1j)
> > > > > > > > > #correct_result.real=result.real-
> > > > np.mean(result.real)
> > > > > > > > > #correct_result.imag = result.imag -
> > > > > > np.mean(result.imag)
> > > > > > > > > PSD = self.fft_test(result)
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > #PSD[8188:8202]=np.mean(PSD[8180:8188])
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > buffs = np.append(buffs,PSD)
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > return complex_buffs,
> > > > > > > > >
> > > > buffs#np.append(buffs[value.samples:],buffs[:value.samples])
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > def test_reciev(self,freq,bandwich):
> > > > > > > > > complex_buffs=np.array([])
> > > > > > > > > buffs = np.array([])
> > > > > > > > > result = np.empty((len([0]), self.samples),
> > > > > > > > dtype=np.complex64)
> > > > > > > > > for i, freqq in enumerate(freq):
> > > > > > > > >
> > > > > > > > > recv_samps = 0
> > > > > > > > > #self.usrp.set_rx_rate(bandwich[i])
> > > > > > > > > k=uhd.types.TuneRequest(freqq)
> > > > > > > > > #k.args(uhd.types.device_addr("mode_n=integer")
> > > > > > > > > )
> > > > > > > > > self.usrp.set_rx_freq(k)
> > > > > > > > >
> > > > > > > > > while
> > > > self.usrp.get_rx_sensor("lo_locked").to_bool()
> > > > > > !=
> > > > > > > > True:
> > > > > > > > > continue
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > while recv_samps < self.samples:
> > > > > > > > >
> > > > > > > > > samps =
> > > > > > > > > self.streamer_rx.recv(self.recv_buff,
> > > > > > > > > self.metadata_rx)
> > > > > > > > > if self.metadata_rx.error_code !=
> > > > > > > > > lib.types.rx_metadata_error_code.none:
> > > > > > > > > print(self.metadata_rx.strerror())
> > > > > > > > > if samps:
> > > > > > > > > real_samps = min(self.samples -
> > > > recv_samps,
> > > > > > > > samps)
> > > > > > > > > result[:, recv_samps:recv_samps +
> > > > real_samps]
> > > > > > =
> > > > > > > > > self.recv_buff[:, 0:real_samps]
> > > > > > > > > recv_samps += real_samps
> > > > > > > > > #print (self.usrp.get_rx_sensor('rssi'))
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > self.stream_cmd.time_spec =
> > > > lib.types.time_spec(0)
> > > > > > > > >
> > > > self.streamer_rx.issue_stream_cmd(self.stream_cmd)
> > > > > > > > >
> > > > complex_buffs=np.append(complex_buffs,result).ravel()
> > > > > > > > > correct_result=result
> > > > > > > > > correct_result_1=result-
> > > > > > > > > (np.mean(result.real)+np.mean(result.imag)*1j)
> > > > > > > > > correct_result.real=result.real-
> > > > np.mean(result.real)
> > > > > > > > > correct_result.imag = result.imag -
> > > > > > np.mean(result.imag)
> > > > > > > > > PSD = self.fft_test(result)
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > #PSD[8188:8202]=np.mean(PSD[8180:8188])
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > buffs = np.append(buffs,PSD)
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > return complex_buffs,
> > > > > > > > >
> > > > buffs#np.append(buffs[value.samples:],buffs[:value.samples])
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > _______________________________________________
> > > > > > > > > USRP-users mailing list
> > > > > > > > > USRP-users@lists.ettus.com
> > > > > > > > >
> > > > http://lists.ettus.com/mailman/listinfo/usrp-users_lists.ettus.com
>
>
_______________________________________________
USRP-users mailing list
USRP-users@lists.ettus.com
http://lists.ettus.com/mailman/listinfo/usrp-users_lists.ettus.com
