On 2022-09-05 10:39, yanzhan...@gmail.com wrote:
Hi, all,
I am having a USRP E312 and is working on implementing a stepped
frequency radar application. The bandwidth of the radar is 1 GHz and
the frequency step size is 10 MHz. My current implementation is
similar to the example code “txrx_loopback_to_file.cpp” : a transmit
thread sending a same baseband signal at the background; a loop
handling the tuning center frequency and receiving data to a buffer.
The following shows the code snippets.
1.
the transmit thread function: just sending a same baseband signal
continuously
void transmit_worker(
std::vector<std::complex<float>> buff,
uhd::tx_streamer::sptr tx_streamer,
uhd::tx_metadata_t metadata,
int num_channels) {
std::vector<std::complex<float>*> buffs(num_channels, &buff.front());
// send data until the signal handler gets called
while (not stop_signal_called) {
// send the entire contents of the buffer tx_streamer->send(buffs,
buff.size(), metadata); metadata.start_of_burst = false;
metadata.has_time_spec = false;
}
// send a mini EOB packet metadata.
end_of_burst = true; tx_streamer->send("", 0, metadata);
}
1.
the loop handling the tuning and receiving:
// tuning and receiving
int count = 100; // number of frequencies
int freq_step = 10e6; // frequency step size
double start = usrp->get_time_now().get_real_secs();
for(int i = 0; i < count; i++) {
uhd::tune_request_t tune_request(600e6 + i*freq_step);
// tuning usrp->set_rx_freq(tune_request, 0);
usrp->set_tx_freq(tune_request, 0); // receive samples
stream_cmd.time_spec = usrp->get_time_now() + uhd::time_spec_t(0.01);
rx_stream->issue_stream_cmd(stream_cmd); size_t num_rx_samps =
rx_stream->recv(buff_ptrs[i], samps_per_buff, md);
}
I use the usrp.get_time_now() function to timing the loop. Here is
what I’ve found: The uhd ad9361 seems to run a calibration procedure
when there is a frequency jump over 100 MHz. And each calibration
takes about 2 seconds for my measurements. With my current setup (100
steps and 10 MHz frequency step size), the total time of the loop is
25.6 seconds. There are 9 calibrations in the loop which takes 18 seconds.
My goal is to find the source code that implements AD9361’s tuning
function in the UHD source code so that I can comment out the
calibration part to speed up the frequency tuning.
The following source code files are related to AD9361 tuning:
*
the set_tx_frequency() implemented in
|uhd/host/lib/usrp/dboard/e3xx/e3xx_radio_control_impl.cpp|
double e3xx_radio_control_impl::set_tx_frequency(const double freq,
const size_t chan) {
RFNOC_LOG_TRACE("set_tx_frequency(f=" << freq << ", chan=" << chan <<
")"); std::lock_guardstd::mutex l(_set_lock);
double clipped_freq = uhd::clip(freq, AD9361_TX_MIN_FREQ,
AD9361_TX_MAX_FREQ);
double coerced_freq =
_ad9361->tune(get_which_ad9361_chain(TX_DIRECTION, chan, _fe_swap),
clipped_freq);
// The E3xx devices have one LO for TX, if we change one channel's
frequency, we change the other, too
for (size_t chan_idx = 0; chan_idx < E3XX_NUM_CHANS; ++chan_idx) {
radio_control_impl::set_tx_frequency(coerced_freq, chan_idx); }
// Front-end switching
_set_atr_bits(chan);
return coerced_freq;
}
*
the tune method in line 227 in the above figure calls the tune()
function in: |uhd/host/lib/usrp/dboard/e3xx/e3xx_ad9361_iface.cpp|
double tune(const std::string& which, const double value) override {
|// return _rpcc->request_with_token<double>( // E3XX_TUNE_TIMEOUT,
this->_rpc_prefix + "catalina_tune", which, value); return
_rpcc->request_with_token<double>( E3XX_TUNE_TIMEOUT,
this->_rpc_prefix + "tune", which, value);|
}
Notice that the original source code is “catalina_tune” and I changed
it to “tune” because my experiments showed “tune” is much faster than
“catalina_tune”.
*
Finally, I find the tune() function above seems to call the tune()
function in:
|uhd/host/lib/usrp/common/ad9361_driver/ad9361_device.cpp|
const double ad9361_device_t::AD9361_MAX_GAIN = 89.75; const double
ad9361_device_t::AD9361_MIN_CLOCK_RATE = 220e3; const double
ad9361_device_t::AD9361_MAX_CLOCK_RATE = 61.44e6; const double
ad9361_device_t::AD9361_CAL_VALID_WINDOW = 100e6; // Max bandwdith is
due to filter rolloff in analog filter stage const double
ad9361_device_t::AD9361_MIN_BW = 200e3; const double
ad9361_device_t::AD9361_MAX_BW = 56e6;
I find in |ad9361_device.cpp |that AD9361_CAL_VALID_WINDOW is
defaulted to 100 MHz and I change the 100 MHz to 1 GHz. But nothing
seems to change, the device still do a calibration every 100 MHz.
I also comment out the calibration code in
|uhd/host/lib/usrp/common/ad9361_driver/ad9361_device.cppb|, but still
nothing seems to be changed. The device is still doing calibration
every 100 MHz.
Anyone knows where the source code for tuning ad9361 with E312 device
is ? I wish I can locate the tuning source code so that I can change
it to speed up frequency tuning. In my application, if I can turn off
the calibration that happens every 100MHz, then the total tuning time
is only 8 seconds, which is just what I need. But I can not locate the
true tuning source code.
Thanks,
Yan
Recent system images for E3xx devices use the MPM architecture, so it's
probably buried in the device-side MPM code.
I haven't found exactly where yet.
But I'll warn you that disabling all the various calibrations of the
AD9361 is done at your own peril.
_______________________________________________
USRP-users mailing list -- usrp-users@lists.ettus.com
To unsubscribe send an email to usrp-users-le...@lists.ettus.com
