1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
|
//
// Copyright 2010 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
#include "usrp_cal_utils.hpp"
#include <uhd/utils/thread_priority.hpp>
#include <uhd/utils/safe_main.hpp>
#include <uhd/utils/paths.hpp>
#include <uhd/utils/algorithm.hpp>
#include <uhd/usrp/multi_usrp.hpp>
#include <boost/program_options.hpp>
#include <boost/format.hpp>
#include <boost/thread/thread.hpp>
#include <boost/math/special_functions/round.hpp>
#include <iostream>
#include <complex>
#include <ctime>
namespace po = boost::program_options;
/***********************************************************************
* Transmit thread
**********************************************************************/
static void tx_thread(uhd::usrp::multi_usrp::sptr usrp, const double tx_wave_freq, const double tx_wave_ampl){
uhd::set_thread_priority_safe();
//create a transmit streamer
uhd::stream_args_t stream_args("fc32"); //complex floats
uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
//setup variables and allocate buffer
uhd::tx_metadata_t md;
md.has_time_spec = false;
std::vector<std::complex<float> > buff(tx_stream->get_max_num_samps()*10);
//values for the wave table lookup
size_t index = 0;
const double tx_rate = usrp->get_tx_rate();
const size_t step = boost::math::iround(wave_table_len * tx_wave_freq/tx_rate);
wave_table table(tx_wave_ampl);
//fill buff and send until interrupted
while (not boost::this_thread::interruption_requested()){
for (size_t i = 0; i < buff.size(); i++){
buff[i] = table(index += step);
}
tx_stream->send(&buff.front(), buff.size(), md);
}
//send a mini EOB packet
md.end_of_burst = true;
tx_stream->send("", 0, md);
}
/***********************************************************************
* Tune RX and TX routine
**********************************************************************/
static double tune_rx_and_tx(uhd::usrp::multi_usrp::sptr usrp, const double tx_lo_freq, const double rx_offset){
//tune the transmitter with no cordic
uhd::tune_request_t tx_tune_req(tx_lo_freq);
tx_tune_req.dsp_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
tx_tune_req.dsp_freq = 0;
usrp->set_tx_freq(tx_tune_req);
//tune the receiver
usrp->set_rx_freq(usrp->get_tx_freq() - rx_offset);
//wait for the LOs to become locked
boost::this_thread::sleep(boost::posix_time::milliseconds(50));
boost::system_time start = boost::get_system_time();
while (not usrp->get_tx_sensor("lo_locked").to_bool() or not usrp->get_rx_sensor("lo_locked").to_bool()){
if (boost::get_system_time() > start + boost::posix_time::milliseconds(100)){
throw std::runtime_error("timed out waiting for TX and/or RX LO to lock");
}
}
return usrp->get_tx_freq();
}
/***********************************************************************
* Main
**********************************************************************/
int UHD_SAFE_MAIN(int argc, char *argv[]){
std::string args;
double tx_wave_freq, tx_wave_ampl, rx_offset;
double freq_start, freq_stop, freq_step;
size_t nsamps;
po::options_description desc("Allowed options");
desc.add_options()
("help", "help message")
("verbose", "enable some verbose")
("args", po::value<std::string>(&args)->default_value(""), "device address args [default = \"\"]")
("tx_wave_freq", po::value<double>(&tx_wave_freq)->default_value(507.123e3), "Transmit wave frequency in Hz")
("tx_wave_ampl", po::value<double>(&tx_wave_ampl)->default_value(0.7), "Transmit wave amplitude in counts")
("rx_offset", po::value<double>(&rx_offset)->default_value(.9344e6), "RX LO offset from the TX LO in Hz")
("freq_start", po::value<double>(&freq_start), "Frequency start in Hz (do not specify for default)")
("freq_stop", po::value<double>(&freq_stop), "Frequency stop in Hz (do not specify for default)")
("freq_step", po::value<double>(&freq_step)->default_value(default_freq_step), "Step size for LO sweep in Hz")
("nsamps", po::value<size_t>(&nsamps)->default_value(default_num_samps), "Samples per data capture")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
//print the help message
if (vm.count("help")){
std::cout << boost::format("USRP Generate TX DC Offset Calibration Table %s") % desc << std::endl;
std::cout <<
"This application measures leakage between RX and TX on an XCVR daughterboard to self-calibrate.\n"
<< std::endl;
return ~0;
}
//create a usrp device
std::cout << std::endl;
std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl;
uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args);
//set the antennas to cal
if (not uhd::has(usrp->get_rx_antennas(), "CAL") or not uhd::has(usrp->get_tx_antennas(), "CAL")){
throw std::runtime_error("This board does not have the CAL antenna option, cannot self-calibrate.");
}
usrp->set_rx_antenna("CAL");
usrp->set_tx_antenna("CAL");
//set optimum defaults
set_optimum_defaults(usrp);
//create a receive streamer
uhd::stream_args_t stream_args("fc32"); //complex floats
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
//create a transmitter thread
boost::thread_group threads;
threads.create_thread(boost::bind(&tx_thread, usrp, tx_wave_freq, tx_wave_ampl));
//re-usable buffer for samples
std::vector<std::complex<float> > buff;
//store the results here
std::vector<result_t> results;
if (not vm.count("freq_start")) freq_start = usrp->get_tx_freq_range().start() + 50e6;
if (not vm.count("freq_stop")) freq_stop = usrp->get_tx_freq_range().stop() - 50e6;
for (double tx_lo_i = freq_start; tx_lo_i <= freq_stop; tx_lo_i += freq_step){
const double tx_lo = tune_rx_and_tx(usrp, tx_lo_i, rx_offset);
//frequency constants for this tune event
const double actual_rx_rate = usrp->get_rx_rate();
const double actual_tx_freq = usrp->get_tx_freq();
const double actual_rx_freq = usrp->get_rx_freq();
const double bb_dc_freq = actual_tx_freq - actual_rx_freq;
//capture initial uncorrected value
usrp->set_tx_dc_offset(std::complex<double>(0, 0));
capture_samples(usrp, rx_stream, buff, nsamps);
const double initial_dc_dbrms = compute_tone_dbrms(buff, bb_dc_freq/actual_rx_rate);
//bounds and results from searching
double dc_i_start = -.01, dc_i_stop = .01, dc_i_step;
double dc_q_start = -.01, dc_q_stop = .01, dc_q_step;
double lowest_offset = 0, best_dc_i = 0, best_dc_q = 0;
for (size_t i = 0; i < num_search_iters; i++){
dc_i_step = (dc_i_stop - dc_i_start)/(num_search_steps-1);
dc_q_step = (dc_q_stop - dc_q_start)/(num_search_steps-1);
for (double dc_i = dc_i_start; dc_i <= dc_i_stop + dc_i_step/2; dc_i += dc_i_step){
for (double dc_q = dc_q_start; dc_q <= dc_q_stop + dc_q_step/2; dc_q += dc_q_step){
const std::complex<double> correction(dc_i, dc_q);
usrp->set_tx_dc_offset(correction);
//receive some samples
capture_samples(usrp, rx_stream, buff, nsamps);
const double dc_dbrms = compute_tone_dbrms(buff, bb_dc_freq/actual_rx_rate);
if (dc_dbrms < lowest_offset){
lowest_offset = dc_dbrms;
best_dc_i = dc_i;
best_dc_q = dc_q;
}
}}
//std::cout << "best_dc_i " << best_dc_i << std::endl;
//std::cout << "best_dc_q " << best_dc_q << std::endl;
//std::cout << "lowest_offset " << lowest_offset << std::endl;
dc_i_start = best_dc_i - dc_i_step;
dc_i_stop = best_dc_i + dc_i_step;
dc_q_start = best_dc_q - dc_q_step;
dc_q_stop = best_dc_q + dc_q_step;
}
if (lowest_offset < initial_dc_dbrms){ //most likely valid, keep result
result_t result;
result.freq = tx_lo;
result.real_corr = best_dc_i;
result.imag_corr = best_dc_q;
result.best = lowest_offset;
result.delta = initial_dc_dbrms - lowest_offset;
results.push_back(result);
if (vm.count("verbose")){
std::cout << boost::format("TX DC: %f MHz: lowest offset %f dB, corrected %f dB") % (tx_lo/1e6) % result.best % result.delta << std::endl;
}
else std::cout << "." << std::flush;
}
}
std::cout << std::endl;
//stop the transmitter
threads.interrupt_all();
threads.join_all();
store_results(usrp, results, "TX", "tx", "dc");
return 0;
}
|
