diff options
Diffstat (limited to 'host')
30 files changed, 1576 insertions, 43 deletions
diff --git a/host/docs/CMakeLists.txt b/host/docs/CMakeLists.txt index fe3799a2f..e393a79f0 100644 --- a/host/docs/CMakeLists.txt +++ b/host/docs/CMakeLists.txt @@ -22,6 +22,7 @@ SET(manual_sources index.rst identification.rst build.rst + calibration.rst coding.rst dboards.rst gpsdo.rst diff --git a/host/docs/calibration.rst b/host/docs/calibration.rst new file mode 100644 index 000000000..0aaace8f4 --- /dev/null +++ b/host/docs/calibration.rst @@ -0,0 +1,56 @@ +======================================================================== +UHD - Calibration Application Notes +======================================================================== + +.. contents:: Table of Contents + +------------------------------------------------------------------------ +Self-calibration +------------------------------------------------------------------------ +The UHD comes with several self-calibration utilities for minimizing IQ imbalance and DC offset. +These utilities perform calibration sweeps using transmit leakage into the receive path +(special equipment is not required). +The results from a calibration are written to a csv file in the user's home directory. +UHD will automatically apply corrections at runtime when the user changes settings. +Calibration results are specific to an individual RF board. + +UHD comes with the following calibration utilities: + + * **uhd_cal_rx_iq_balance:** - mimimizes RX IQ imbalance vs LO frequency + * **uhd_cal_tx_dc_offset:** - mimimizes TX DC offset vs LO frequency + * **uhd_cal_tx_iq_balance:** - mimimizes TX IQ imbalance vs LO frequency + + +The following RF frontends are supported by the self-calibration utilities: + + * WBX transceiver board + * SBX transceiver board + * more to come... + +******************************************** +Calibration utilities +******************************************** +UHD installs the calibration utilities into <install-path>/bin. +**Disconnect** any extrernal hardware from the RF antenna ports, +and run the following from the command line. +Each utility will take several minutes to complete. +:: + + uhd_cal_rx_iq_balance --verbose --args=<optional device args> + uhd_cal_tx_iq_balance --verbose --args=<optional device args> + uhd_cal_tx_dc_offset --verbose --args=<optional device args> + +See the output given by --help for more advanced options, such as: +manually choosing the frequency range and step size for the sweeps. + +******************************************** +Calibration data +******************************************** +Calibration files are stored in the user's home/application directory. +They can easily be moved from machine to another by copying the "cal" directory. +Re-running a calibration utility will replace the existing calibration file. +The old calibration file will be renamed so it may be recovered by the user. + + * **Unix:** ${HOME}/.uhd/cal/ + * **Windows:** %APPDATA%\\.uhd\\cal\\ + diff --git a/host/docs/index.rst b/host/docs/index.rst index 0b24927e9..f881e8585 100644 --- a/host/docs/index.rst +++ b/host/docs/index.rst @@ -30,6 +30,7 @@ Application Notes * `Transport Application Notes <./transport.html>`_ * `Synchronization Application Notes <./sync.html>`_ * `Internal GPSDO Application Notes <./gpsdo.html>`_ +* `Calibration Application Notes <./calibration.html>`_ ^^^^^^^^^^^^^^^^^^^^^ API Documentation diff --git a/host/include/uhd/utils/CMakeLists.txt b/host/include/uhd/utils/CMakeLists.txt index 48b8db885..5a434fd9a 100644 --- a/host/include/uhd/utils/CMakeLists.txt +++ b/host/include/uhd/utils/CMakeLists.txt @@ -21,10 +21,12 @@ INSTALL(FILES assert_has.ipp byteswap.hpp byteswap.ipp + csv.hpp gain_group.hpp images.hpp log.hpp msg.hpp + paths.hpp pimpl.hpp safe_call.hpp safe_main.hpp diff --git a/host/include/uhd/utils/csv.hpp b/host/include/uhd/utils/csv.hpp new file mode 100644 index 000000000..8dbb28377 --- /dev/null +++ b/host/include/uhd/utils/csv.hpp @@ -0,0 +1,35 @@ +// +// Copyright 2011 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/>. +// + +#ifndef INCLUDED_UHD_UTILS_CSV_HPP +#define INCLUDED_UHD_UTILS_CSV_HPP + +#include <uhd/config.hpp> +#include <vector> +#include <string> +#include <istream> + +namespace uhd{ namespace csv{ + typedef std::vector<std::string> row_type; + typedef std::vector<row_type> rows_type; + + //! Convert an input stream to csv rows. + UHD_API rows_type to_rows(std::istream &input); + +}} //namespace uhd::csv + +#endif /* INCLUDED_UHD_UTILS_CSV_HPP */ diff --git a/host/include/uhd/utils/paths.hpp b/host/include/uhd/utils/paths.hpp new file mode 100644 index 000000000..2261f1b77 --- /dev/null +++ b/host/include/uhd/utils/paths.hpp @@ -0,0 +1,34 @@ +// +// Copyright 2011 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/>. +// + +#ifndef INCLUDED_UHD_UTILS_PATHS_HPP +#define INCLUDED_UHD_UTILS_PATHS_HPP + +#include <uhd/config.hpp> +#include <string> + +namespace uhd{ + + //! Get a string representing the system's temporary directory + UHD_API std::string get_tmp_path(void); + + //! Get a string representing the system's appdata directory + UHD_API std::string get_app_path(void); + +} //namespace uhd + +#endif /* INCLUDED_UHD_UTILS_PATHS_HPP */ diff --git a/host/lib/usrp/b100/b100_impl.cpp b/host/lib/usrp/b100/b100_impl.cpp index c506559be..7674a0fcf 100644 --- a/host/lib/usrp/b100/b100_impl.cpp +++ b/host/lib/usrp/b100/b100_impl.cpp @@ -15,6 +15,7 @@ // along with this program. If not, see <http://www.gnu.org/licenses/>. // +#include "apply_corrections.hpp" #include "b100_impl.hpp" #include "b100_ctrl.hpp" #include "fpga_regs_standard.h" @@ -293,13 +294,13 @@ b100_impl::b100_impl(const device_addr_t &device_addr){ .set(true); _tree->create<std::complex<double> >(rx_fe_path / "iq_balance" / "value") .subscribe(boost::bind(&rx_frontend_core_200::set_iq_balance, _rx_fe, _1)) - .set(std::complex<double>(0.0, 0.0)); + .set(std::polar<double>(1.0, 0.0)); _tree->create<std::complex<double> >(tx_fe_path / "dc_offset" / "value") .coerce(boost::bind(&tx_frontend_core_200::set_dc_offset, _tx_fe, _1)) .set(std::complex<double>(0.0, 0.0)); _tree->create<std::complex<double> >(tx_fe_path / "iq_balance" / "value") .subscribe(boost::bind(&tx_frontend_core_200::set_iq_balance, _tx_fe, _1)) - .set(std::complex<double>(0.0, 0.0)); + .set(std::polar<double>(1.0, 0.0)); //////////////////////////////////////////////////////////////////// // create rx dsp control objects @@ -408,6 +409,18 @@ b100_impl::b100_impl(const device_addr_t &device_addr){ _dboard_iface, _tree->subtree(mb_path / "dboards/A") ); + //bind frontend corrections to the dboard freq props + const fs_path db_tx_fe_path = mb_path / "dboards" / "A" / "tx_frontends"; + BOOST_FOREACH(const std::string &name, _tree->list(db_tx_fe_path)){ + _tree->access<double>(db_tx_fe_path / name / "freq" / "value") + .subscribe(boost::bind(&b100_impl::set_tx_fe_corrections, this, _1)); + } + const fs_path db_rx_fe_path = mb_path / "dboards" / "A" / "rx_frontends"; + BOOST_FOREACH(const std::string &name, _tree->list(db_rx_fe_path)){ + _tree->access<double>(db_rx_fe_path / name / "freq" / "value") + .subscribe(boost::bind(&b100_impl::set_rx_fe_corrections, this, _1)); + } + //initialize io handling this->io_init(); @@ -501,3 +514,11 @@ sensor_value_t b100_impl::get_ref_locked(void){ const bool lock = _clock_ctrl->get_locked(); return sensor_value_t("Ref", lock, "locked", "unlocked"); } + +void b100_impl::set_rx_fe_corrections(const double lo_freq){ + apply_rx_fe_corrections(this->get_tree()->subtree("/mboards/0"), "A", lo_freq); +} + +void b100_impl::set_tx_fe_corrections(const double lo_freq){ + apply_tx_fe_corrections(this->get_tree()->subtree("/mboards/0"), "A", lo_freq); +} diff --git a/host/lib/usrp/b100/b100_impl.hpp b/host/lib/usrp/b100/b100_impl.hpp index 0984260be..96d90b14c 100644 --- a/host/lib/usrp/b100/b100_impl.hpp +++ b/host/lib/usrp/b100/b100_impl.hpp @@ -125,6 +125,8 @@ private: void clear_fpga_fifo(void); void handle_async_message(uhd::transport::managed_recv_buffer::sptr); uhd::sensor_value_t get_ref_locked(void); + void set_rx_fe_corrections(const double); + void set_tx_fe_corrections(const double); }; #endif /* INCLUDED_b100_IMPL_HPP */ diff --git a/host/lib/usrp/common/CMakeLists.txt b/host/lib/usrp/common/CMakeLists.txt index ec8b60fec..9abd34afa 100644 --- a/host/lib/usrp/common/CMakeLists.txt +++ b/host/lib/usrp/common/CMakeLists.txt @@ -29,6 +29,7 @@ ENDIF(ENABLE_USB) INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) LIBUHD_APPEND_SOURCES( + ${CMAKE_CURRENT_SOURCE_DIR}/apply_corrections.cpp ${CMAKE_CURRENT_SOURCE_DIR}/validate_subdev_spec.cpp ${CMAKE_CURRENT_SOURCE_DIR}/recv_packet_demuxer.cpp ) diff --git a/host/lib/usrp/common/apply_corrections.cpp b/host/lib/usrp/common/apply_corrections.cpp new file mode 100644 index 000000000..6aee00753 --- /dev/null +++ b/host/lib/usrp/common/apply_corrections.cpp @@ -0,0 +1,217 @@ +// +// Copyright 2011 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 "apply_corrections.hpp" +#include <uhd/usrp/dboard_eeprom.hpp> +#include <uhd/utils/paths.hpp> +#include <uhd/utils/msg.hpp> +#include <uhd/utils/csv.hpp> +#include <uhd/types/dict.hpp> +#include <boost/filesystem.hpp> +#include <boost/foreach.hpp> +#include <boost/thread/mutex.hpp> +#include <cstdio> +#include <complex> +#include <fstream> + +namespace fs = boost::filesystem; + +boost::mutex corrections_mutex; + +/*********************************************************************** + * Helper routines + **********************************************************************/ +static double linear_interp(double x, double x0, double y0, double x1, double y1){ + return y0 + (x - x0)*(y1 - y0)/(x1 - x0); +} + +/*********************************************************************** + * FE apply corrections implementation + **********************************************************************/ +struct fe_cal_t{ + double lo_freq; + double iq_corr_real; + double iq_corr_imag; +}; + +static bool fe_cal_comp(fe_cal_t a, fe_cal_t b){ + return (a.lo_freq < b.lo_freq); +} + +static uhd::dict<std::string, std::vector<fe_cal_t> > fe_cal_cache; + +static std::complex<double> get_fe_dc_correction( + const std::string &key, const double lo_freq +){ + const std::vector<fe_cal_t> &datas = fe_cal_cache[key]; + if (datas.empty()) throw uhd::runtime_error("empty calibration table " + key); + + //search for lo freq + size_t lo_index = 0; + size_t hi_index = datas.size()-1; + for (size_t i = 0; i < datas.size(); i++){ + if (datas[i].lo_freq > lo_freq){ + hi_index = i; + break; + } + lo_index = i; + } + + if (lo_index == 0) return std::complex<double>(datas[lo_index].iq_corr_real, datas[lo_index].iq_corr_imag); + if (hi_index == lo_index) return std::complex<double>(datas[hi_index].iq_corr_real, datas[hi_index].iq_corr_imag); + + //interpolation time + return std::complex<double>( + linear_interp(lo_freq, datas[lo_index].lo_freq, datas[lo_index].iq_corr_real, datas[hi_index].lo_freq, datas[hi_index].iq_corr_real), + linear_interp(lo_freq, datas[lo_index].lo_freq, datas[lo_index].iq_corr_imag, datas[hi_index].lo_freq, datas[hi_index].iq_corr_imag) + ); +} + +static std::complex<double> get_fe_iq_correction( + const std::string &key, const double lo_freq +){ + const std::vector<fe_cal_t> &datas = fe_cal_cache[key]; + if (datas.empty()) throw uhd::runtime_error("empty calibration table " + key); + + //search for lo freq + size_t lo_index = 0; + size_t hi_index = datas.size()-1; + for (size_t i = 0; i < datas.size(); i++){ + if (datas[i].lo_freq > lo_freq){ + hi_index = i; + break; + } + lo_index = i; + } + + if (lo_index == 0) return std::complex<double>(datas[lo_index].iq_corr_real, datas[lo_index].iq_corr_imag); + if (hi_index == lo_index) return std::complex<double>(datas[hi_index].iq_corr_real, datas[hi_index].iq_corr_imag); + + const std::complex<double> lo_val(datas[lo_index].iq_corr_real, datas[lo_index].iq_corr_imag); + const std::complex<double> hi_val(datas[hi_index].iq_corr_real, datas[hi_index].iq_corr_imag); + + //interpolation time + return std::polar<double>( + linear_interp(lo_freq, datas[lo_index].lo_freq, std::abs(lo_val), datas[hi_index].lo_freq, std::abs(hi_val)), + linear_interp(lo_freq, datas[lo_index].lo_freq, std::arg(lo_val), datas[hi_index].lo_freq, std::arg(hi_val)) + ); +} + +static void apply_fe_corrections( + uhd::property_tree::sptr sub_tree, + const uhd::fs_path &db_path, + const uhd::fs_path &fe_path, + const std::string &file_prefix, + const double lo_freq +){ + //extract eeprom serial + const uhd::usrp::dboard_eeprom_t db_eeprom = sub_tree->access<uhd::usrp::dboard_eeprom_t>(db_path).get(); + + //make the calibration file path + const fs::path cal_data_path = fs::path(uhd::get_app_path()) / ".uhd" / "cal" / (file_prefix + db_eeprom.serial + ".csv"); + if (not fs::exists(cal_data_path)) return; + + //parse csv file or get from cache + if (not fe_cal_cache.has_key(cal_data_path.string())){ + std::ifstream cal_data(cal_data_path.string().c_str()); + const uhd::csv::rows_type rows = uhd::csv::to_rows(cal_data); + + bool read_data = false, skip_next = false;; + std::vector<fe_cal_t> datas; + BOOST_FOREACH(const uhd::csv::row_type &row, rows){ + if (not read_data and not row.empty() and row[0] == "DATA STARTS HERE"){ + read_data = true; + skip_next = true; + continue; + } + if (not read_data) continue; + if (skip_next){ + skip_next = false; + continue; + } + fe_cal_t data; + std::sscanf(row[0].c_str(), "%lf" , &data.lo_freq); + std::sscanf(row[1].c_str(), "%lf" , &data.iq_corr_real); + std::sscanf(row[2].c_str(), "%lf" , &data.iq_corr_imag); + datas.push_back(data); + } + std::sort(datas.begin(), datas.end(), fe_cal_comp); + fe_cal_cache[cal_data_path.string()] = datas; + UHD_MSG(status) << "Loaded " << cal_data_path.string() << std::endl; + + } + + if (file_prefix.find("dc_cal") != std::string::npos){ + sub_tree->access<std::complex<double> >(fe_path) + .set(get_fe_dc_correction(cal_data_path.string(), lo_freq)); + } + else if (file_prefix.find("iq_cal") != std::string::npos){ + sub_tree->access<std::complex<double> >(fe_path) + .set(get_fe_iq_correction(cal_data_path.string(), lo_freq)); + } + else throw uhd::runtime_error("could not determine interpolation function"); +} + +/*********************************************************************** + * Wrapper routines with nice try/catch + print + **********************************************************************/ +void uhd::usrp::apply_tx_fe_corrections( + property_tree::sptr sub_tree, //starts at mboards/x + const std::string &slot, //name of dboard slot + const double lo_freq //actual lo freq +){ + boost::mutex::scoped_lock l(corrections_mutex); + try{ + apply_fe_corrections( + sub_tree, + "dboards/" + slot + "/tx_eeprom", + "tx_frontends/" + slot + "/iq_balance/value", + "tx_iq_cal_v0.1_", + lo_freq + ); + apply_fe_corrections( + sub_tree, + "dboards/" + slot + "/tx_eeprom", + "tx_frontends/" + slot + "/dc_offset/value", + "tx_dc_cal_v0.1_", + lo_freq + ); + } + catch(const std::exception &e){ + UHD_MSG(error) << "Failure in apply_tx_fe_corrections: " << e.what() << std::endl; + } +} + +void uhd::usrp::apply_rx_fe_corrections( + property_tree::sptr sub_tree, //starts at mboards/x + const std::string &slot, //name of dboard slot + const double lo_freq //actual lo freq +){ + boost::mutex::scoped_lock l(corrections_mutex); + try{ + apply_fe_corrections( + sub_tree, + "dboards/" + slot + "/rx_eeprom", + "rx_frontends/" + slot + "/iq_balance/value", + "rx_iq_cal_v0.1_", + lo_freq + ); + } + catch(const std::exception &e){ + UHD_MSG(error) << "Failure in apply_rx_fe_corrections: " << e.what() << std::endl; + } +} diff --git a/host/lib/usrp/common/apply_corrections.hpp b/host/lib/usrp/common/apply_corrections.hpp new file mode 100644 index 000000000..c516862d1 --- /dev/null +++ b/host/lib/usrp/common/apply_corrections.hpp @@ -0,0 +1,41 @@ +// +// Copyright 2011 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/>. +// + +#ifndef INCLUDED_LIBUHD_USRP_COMMON_APPLY_CORRECTIONS_HPP +#define INCLUDED_LIBUHD_USRP_COMMON_APPLY_CORRECTIONS_HPP + +#include <uhd/config.hpp> +#include <uhd/property_tree.hpp> +#include <string> + +namespace uhd{ namespace usrp{ + + void apply_tx_fe_corrections( + property_tree::sptr sub_tree, //starts at mboards/x + const std::string &slot, //name of dboard slot + const double tx_lo_freq //actual lo freq + ); + + void apply_rx_fe_corrections( + property_tree::sptr sub_tree, //starts at mboards/x + const std::string &slot, //name of dboard slot + const double rx_lo_freq //actual lo freq + ); + +}} //namespace uhd::usrp + +#endif /* INCLUDED_LIBUHD_USRP_COMMON_APPLY_CORRECTIONS_HPP */ diff --git a/host/lib/usrp/cores/rx_frontend_core_200.cpp b/host/lib/usrp/cores/rx_frontend_core_200.cpp index d42022947..d6396ef45 100644 --- a/host/lib/usrp/cores/rx_frontend_core_200.cpp +++ b/host/lib/usrp/cores/rx_frontend_core_200.cpp @@ -64,8 +64,8 @@ public: } void set_iq_balance(const std::complex<double> &cor){ - _iface->poke32(REG_RX_FE_MAG_CORRECTION, fs_to_bits(std::abs(cor), 18)); - _iface->poke32(REG_RX_FE_PHASE_CORRECTION, fs_to_bits(std::atan2(cor.real(), cor.imag()), 18)); + _iface->poke32(REG_RX_FE_MAG_CORRECTION, fs_to_bits(std::abs(cor) - 1, 18)); + _iface->poke32(REG_RX_FE_PHASE_CORRECTION, fs_to_bits(std::arg(cor)/6.28318531, 18)); } private: diff --git a/host/lib/usrp/cores/tx_frontend_core_200.cpp b/host/lib/usrp/cores/tx_frontend_core_200.cpp index 327e8d344..b90281d9f 100644 --- a/host/lib/usrp/cores/tx_frontend_core_200.cpp +++ b/host/lib/usrp/cores/tx_frontend_core_200.cpp @@ -62,8 +62,8 @@ public: } void set_iq_balance(const std::complex<double> &cor){ - _iface->poke32(REG_TX_FE_MAG_CORRECTION, fs_to_bits(std::abs(cor), 18)); - _iface->poke32(REG_TX_FE_PHASE_CORRECTION, fs_to_bits(std::atan2(cor.real(), cor.imag()), 18)); + _iface->poke32(REG_TX_FE_MAG_CORRECTION, fs_to_bits(std::abs(cor) - 1, 18)); + _iface->poke32(REG_TX_FE_PHASE_CORRECTION, fs_to_bits(std::arg(cor)/6.28318531, 18)); } private: diff --git a/host/lib/usrp/dboard/db_rfx.cpp b/host/lib/usrp/dboard/db_rfx.cpp index 3896534cd..58382f180 100644 --- a/host/lib/usrp/dboard/db_rfx.cpp +++ b/host/lib/usrp/dboard/db_rfx.cpp @@ -56,9 +56,9 @@ using namespace boost::assign; /*********************************************************************** * The RFX Series constants **********************************************************************/ -static const std::vector<std::string> rfx_tx_antennas = list_of("TX/RX"); +static const std::vector<std::string> rfx_tx_antennas = list_of("TX/RX")("CAL"); -static const std::vector<std::string> rfx_rx_antennas = list_of("TX/RX")("RX2"); +static const std::vector<std::string> rfx_rx_antennas = list_of("TX/RX")("RX2")("CAL"); static const uhd::dict<std::string, gain_range_t> rfx_rx_gain_ranges = map_list_of ("PGA0", gain_range_t(0, 70, 0.022)) @@ -271,10 +271,17 @@ void rfx_xcvr::set_rx_ant(const std::string &ant){ assert_has(rfx_rx_antennas, ant, "rfx rx antenna name"); //set the rx atr regs that change with antenna setting - this->get_iface()->set_atr_reg( - dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, - _power_up | MIXER_ENB | ((ant == "TX/RX")? ANT_TXRX : ANT_RX2) - ); + if (ant == "CAL") { + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, _power_up | ANT_TXRX | MIXER_DIS); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, _power_up | ANT_TXRX | MIXER_ENB); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, _power_up | MIXER_ENB | ANT_TXRX ); + } + else { + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, _power_up | ANT_XX | MIXER_DIS); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, _power_up | ANT_RX2| MIXER_ENB); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, _power_up | MIXER_ENB | + ((ant == "TX/RX")? ANT_TXRX : ANT_RX2)); + } //shadow the setting _rx_ant = ant; @@ -282,7 +289,16 @@ void rfx_xcvr::set_rx_ant(const std::string &ant){ void rfx_xcvr::set_tx_ant(const std::string &ant){ assert_has(rfx_tx_antennas, ant, "rfx tx antenna name"); - //only one antenna option, do nothing + + //set the tx atr regs that change with antenna setting + if (ant == "CAL") { + this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY, _power_up | ANT_RX | MIXER_ENB); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX, _power_up | ANT_RX | MIXER_ENB); + } + else { + this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY, _power_up | ANT_TX | MIXER_ENB); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX, _power_up | ANT_TX | MIXER_ENB); + } } /*********************************************************************** diff --git a/host/lib/usrp/dboard/db_sbx_common.cpp b/host/lib/usrp/dboard/db_sbx_common.cpp index 27b930f81..32b6730d5 100644 --- a/host/lib/usrp/dboard/db_sbx_common.cpp +++ b/host/lib/usrp/dboard/db_sbx_common.cpp @@ -216,35 +216,37 @@ void sbx_xcvr::update_atr(void){ int rx_ld_led = get_locked(dboard_iface::UNIT_RX).to_bool() ? 0 : RX_LED_LD; int tx_ld_led = get_locked(dboard_iface::UNIT_TX).to_bool() ? 0 : TX_LED_LD; int rx_ant_led = _rx_ant == "TX/RX" ? RX_LED_RX1RX2 : 0; - int tx_ant_led = _rx_ant == "TX/RX" ? 0 : TX_LED_TXRX; + int tx_ant_led = _tx_ant == "TX/RX" ? 0 : TX_LED_TXRX; //setup the tx atr (this does not change with antenna) this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_IDLE, tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | ANT_XX | TX_MIXER_DIS); - this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY, - tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | ANT_TX | TX_MIXER_ENB); - this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX, - tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | ANT_TX | TX_MIXER_ENB); //setup the rx atr (this does not change with antenna) this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_IDLE, rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | ANT_XX | RX_MIXER_DIS); + + //set the RX atr regs that change with antenna setting + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, + rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | RX_MIXER_ENB | + ((_rx_ant != "RX2")? ANT_TXRX : ANT_RX2)); this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, - rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | ANT_RX2 | RX_MIXER_DIS); + rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | RX_MIXER_DIS | + ((_rx_ant == "CAL")? ANT_TXRX : ANT_RX2)); this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, - rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | ANT_RX2 | RX_MIXER_ENB); + rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | RX_MIXER_ENB | + ((_rx_ant == "CAL")? ANT_TXRX : ANT_RX2)); - //set the atr regs that change with antenna setting + //set the TX atr regs that change with antenna setting this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_RX_ONLY, tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | TX_MIXER_DIS | - ((_rx_ant == "TX/RX")? ANT_RX : ANT_TX)); - this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, - rx_pga0_iobits | rx_lo_lpf_en | rx_ld_led | rx_ant_led | RX_POWER_UP | RX_MIXER_ENB | - ((_rx_ant == "TX/RX")? ANT_TXRX : ANT_RX2)); - - UHD_LOGV(often) << boost::format( - "SBX RXONLY ATR REG: 0x%08x" - ) % (rx_pga0_iobits | RX_POWER_UP | RX_MIXER_ENB | ((_rx_ant == "TX/RX")? ANT_TXRX : ANT_RX2)) << std::endl; + ((_rx_ant != "RX2")? ANT_RX : ANT_TX)); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY, + tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | TX_MIXER_ENB | + ((_tx_ant == "CAL")? ANT_RX : ANT_TX)); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX, + tx_pga0_iobits | tx_lo_lpf_en | tx_ld_led | tx_ant_led | TX_POWER_UP | TX_MIXER_ENB | + ((_tx_ant == "CAL")? ANT_RX : ANT_TX)); } void sbx_xcvr::set_rx_ant(const std::string &ant){ @@ -260,7 +262,12 @@ void sbx_xcvr::set_rx_ant(const std::string &ant){ void sbx_xcvr::set_tx_ant(const std::string &ant){ assert_has(sbx_tx_antennas, ant, "sbx tx antenna name"); - //only one antenna option, do nothing + + //shadow the setting + _tx_ant = ant; + + //write the new antenna setting to atr regs + update_atr(); } /*********************************************************************** diff --git a/host/lib/usrp/dboard/db_sbx_common.hpp b/host/lib/usrp/dboard/db_sbx_common.hpp index c90cce456..8997350ae 100644 --- a/host/lib/usrp/dboard/db_sbx_common.hpp +++ b/host/lib/usrp/dboard/db_sbx_common.hpp @@ -113,9 +113,9 @@ static const freq_range_t sbx_enable_rx_lo_filter = list_of (range_t(0.4e9, 1.5e9)) ; -static const std::vector<std::string> sbx_tx_antennas = list_of("TX/RX"); +static const std::vector<std::string> sbx_tx_antennas = list_of("TX/RX")("CAL"); -static const std::vector<std::string> sbx_rx_antennas = list_of("TX/RX")("RX2"); +static const std::vector<std::string> sbx_rx_antennas = list_of("TX/RX")("RX2")("CAL"); static const uhd::dict<std::string, gain_range_t> sbx_tx_gain_ranges = map_list_of ("PGA0", gain_range_t(0, 31.5, double(0.5))) diff --git a/host/lib/usrp/dboard/db_wbx_simple.cpp b/host/lib/usrp/dboard/db_wbx_simple.cpp index f46ea70d1..3d633a672 100644 --- a/host/lib/usrp/dboard/db_wbx_simple.cpp +++ b/host/lib/usrp/dboard/db_wbx_simple.cpp @@ -36,9 +36,9 @@ using namespace boost::assign; /*********************************************************************** * The WBX Simple dboard constants **********************************************************************/ -static const std::vector<std::string> wbx_tx_antennas = list_of("TX/RX"); +static const std::vector<std::string> wbx_tx_antennas = list_of("TX/RX")("CAL"); -static const std::vector<std::string> wbx_rx_antennas = list_of("TX/RX")("RX2"); +static const std::vector<std::string> wbx_rx_antennas = list_of("TX/RX")("RX2")("CAL"); /*********************************************************************** * The WBX simple implementation @@ -132,10 +132,28 @@ void wbx_simple::set_rx_ant(const std::string &ant){ _rx_ant = ant; //write the new antenna setting to atr regs - this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, ((_rx_ant == "TX/RX")? ANT_TXRX : ANT_RX2), ANTSW_IO); + if (_rx_ant == "CAL") { + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, ANT_TXRX, ANTSW_IO); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, ANT_TXRX, ANTSW_IO); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, ANT_TXRX, ANTSW_IO); + } + else { + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_TX_ONLY, ANT_RX2, ANTSW_IO); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_FULL_DUPLEX, ANT_RX2, ANTSW_IO); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_RX, dboard_iface::ATR_REG_RX_ONLY, ((_rx_ant == "TX/RX")? ANT_TXRX : ANT_RX2), ANTSW_IO); + } } void wbx_simple::set_tx_ant(const std::string &ant){ assert_has(wbx_tx_antennas, ant, "wbx tx antenna name"); - //only one antenna option, do nothing + + //write the new antenna setting to atr regs + if (ant == "CAL") { + this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY, ANT_RX, ANTSW_IO); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX, ANT_RX, ANTSW_IO); + } + else { + this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_TX_ONLY, ANT_TX, ANTSW_IO); + this->get_iface()->set_atr_reg(dboard_iface::UNIT_TX, dboard_iface::ATR_REG_FULL_DUPLEX, ANT_TX, ANTSW_IO); + } } diff --git a/host/lib/usrp/e100/e100_impl.cpp b/host/lib/usrp/e100/e100_impl.cpp index c0a8f46f3..8b7756461 100644 --- a/host/lib/usrp/e100/e100_impl.cpp +++ b/host/lib/usrp/e100/e100_impl.cpp @@ -15,6 +15,7 @@ // along with this program. If not, see <http://www.gnu.org/licenses/>. // +#include "apply_corrections.hpp" #include "e100_impl.hpp" #include "e100_regs.hpp" #include <uhd/utils/msg.hpp> @@ -259,13 +260,13 @@ e100_impl::e100_impl(const uhd::device_addr_t &device_addr){ .set(true); _tree->create<std::complex<double> >(rx_fe_path / "iq_balance" / "value") .subscribe(boost::bind(&rx_frontend_core_200::set_iq_balance, _rx_fe, _1)) - .set(std::complex<double>(0.0, 0.0)); + .set(std::polar<double>(1.0, 0.0)); _tree->create<std::complex<double> >(tx_fe_path / "dc_offset" / "value") .coerce(boost::bind(&tx_frontend_core_200::set_dc_offset, _tx_fe, _1)) .set(std::complex<double>(0.0, 0.0)); _tree->create<std::complex<double> >(tx_fe_path / "iq_balance" / "value") .subscribe(boost::bind(&tx_frontend_core_200::set_iq_balance, _tx_fe, _1)) - .set(std::complex<double>(0.0, 0.0)); + .set(std::polar<double>(1.0, 0.0)); //////////////////////////////////////////////////////////////////// // create rx dsp control objects @@ -374,6 +375,18 @@ e100_impl::e100_impl(const uhd::device_addr_t &device_addr){ _dboard_iface, _tree->subtree(mb_path / "dboards/A") ); + //bind frontend corrections to the dboard freq props + const fs_path db_tx_fe_path = mb_path / "dboards" / "A" / "tx_frontends"; + BOOST_FOREACH(const std::string &name, _tree->list(db_tx_fe_path)){ + _tree->access<double>(db_tx_fe_path / name / "freq" / "value") + .subscribe(boost::bind(&e100_impl::set_tx_fe_corrections, this, _1)); + } + const fs_path db_rx_fe_path = mb_path / "dboards" / "A" / "rx_frontends"; + BOOST_FOREACH(const std::string &name, _tree->list(db_rx_fe_path)){ + _tree->access<double>(db_rx_fe_path / name / "freq" / "value") + .subscribe(boost::bind(&e100_impl::set_rx_fe_corrections, this, _1)); + } + //initialize io handling this->io_init(); @@ -450,3 +463,11 @@ void e100_impl::check_fpga_compat(void){ } _tree->create<std::string>("/mboards/0/fpga_version").set(str(boost::format("%u.%u") % fpga_major % fpga_minor)); } + +void e100_impl::set_rx_fe_corrections(const double lo_freq){ + apply_rx_fe_corrections(this->get_tree()->subtree("/mboards/0"), "A", lo_freq); +} + +void e100_impl::set_tx_fe_corrections(const double lo_freq){ + apply_tx_fe_corrections(this->get_tree()->subtree("/mboards/0"), "A", lo_freq); +} diff --git a/host/lib/usrp/e100/e100_impl.hpp b/host/lib/usrp/e100/e100_impl.hpp index f3e481b93..2ea890375 100644 --- a/host/lib/usrp/e100/e100_impl.hpp +++ b/host/lib/usrp/e100/e100_impl.hpp @@ -130,6 +130,8 @@ private: void update_clock_source(const std::string &); uhd::sensor_value_t get_ref_locked(void); void check_fpga_compat(void); + void set_rx_fe_corrections(const double); + void set_tx_fe_corrections(const double); }; diff --git a/host/lib/usrp/multi_usrp.cpp b/host/lib/usrp/multi_usrp.cpp index 1110f5ebd..6fd60fb6f 100644 --- a/host/lib/usrp/multi_usrp.cpp +++ b/host/lib/usrp/multi_usrp.cpp @@ -50,10 +50,15 @@ static void do_samp_rate_warning_message( } static void do_tune_freq_warning_message( - double target_freq, + const tune_request_t &tune_req, double actual_freq, const std::string &xx ){ + //forget the warning when manual policy + if (tune_req.dsp_freq_policy == tune_request_t::POLICY_MANUAL) return; + if (tune_req.rf_freq_policy == tune_request_t::POLICY_MANUAL) return; + + const double target_freq = tune_req.target_freq; static const double max_allowed_error = 1.0; //Hz if (std::abs(target_freq - actual_freq) > max_allowed_error){ UHD_MSG(warning) << boost::format( @@ -486,7 +491,7 @@ public: tune_result_t set_rx_freq(const tune_request_t &tune_request, size_t chan){ tune_result_t r = tune_xx_subdev_and_dsp(RX_SIGN, _tree->subtree(rx_dsp_root(chan)), _tree->subtree(rx_rf_fe_root(chan)), tune_request); - do_tune_freq_warning_message(tune_request.target_freq, get_rx_freq(chan), "RX"); + do_tune_freq_warning_message(tune_request, get_rx_freq(chan), "RX"); return r; } @@ -634,7 +639,7 @@ public: tune_result_t set_tx_freq(const tune_request_t &tune_request, size_t chan){ tune_result_t r = tune_xx_subdev_and_dsp(TX_SIGN, _tree->subtree(tx_dsp_root(chan)), _tree->subtree(tx_rf_fe_root(chan)), tune_request); - do_tune_freq_warning_message(tune_request.target_freq, get_tx_freq(chan), "TX"); + do_tune_freq_warning_message(tune_request, get_tx_freq(chan), "TX"); return r; } diff --git a/host/lib/usrp/usrp2/usrp2_impl.cpp b/host/lib/usrp/usrp2/usrp2_impl.cpp index bb3bfc7e4..87e5596a3 100644 --- a/host/lib/usrp/usrp2/usrp2_impl.cpp +++ b/host/lib/usrp/usrp2/usrp2_impl.cpp @@ -17,6 +17,7 @@ #include "usrp2_impl.hpp" #include "fw_common.h" +#include "apply_corrections.hpp" #include <uhd/utils/log.hpp> #include <uhd/utils/msg.hpp> #include <uhd/exception.hpp> @@ -473,13 +474,13 @@ usrp2_impl::usrp2_impl(const device_addr_t &_device_addr){ .set(true); _tree->create<std::complex<double> >(rx_fe_path / "iq_balance" / "value") .subscribe(boost::bind(&rx_frontend_core_200::set_iq_balance, _mbc[mb].rx_fe, _1)) - .set(std::complex<double>(0.0, 0.0)); + .set(std::polar<double>(1.0, 0.0)); _tree->create<std::complex<double> >(tx_fe_path / "dc_offset" / "value") .coerce(boost::bind(&tx_frontend_core_200::set_dc_offset, _mbc[mb].tx_fe, _1)) .set(std::complex<double>(0.0, 0.0)); _tree->create<std::complex<double> >(tx_fe_path / "iq_balance" / "value") .subscribe(boost::bind(&tx_frontend_core_200::set_iq_balance, _mbc[mb].tx_fe, _1)) - .set(std::complex<double>(0.0, 0.0)); + .set(std::polar<double>(1.0, 0.0)); //////////////////////////////////////////////////////////////// // create rx dsp control objects @@ -600,6 +601,18 @@ usrp2_impl::usrp2_impl(const device_addr_t &_device_addr){ rx_db_eeprom.id, tx_db_eeprom.id, gdb_eeprom.id, _mbc[mb].dboard_iface, _tree->subtree(mb_path / "dboards/A") ); + + //bind frontend corrections to the dboard freq props + const fs_path db_tx_fe_path = mb_path / "dboards" / "A" / "tx_frontends"; + BOOST_FOREACH(const std::string &name, _tree->list(db_tx_fe_path)){ + _tree->access<double>(db_tx_fe_path / name / "freq" / "value") + .subscribe(boost::bind(&usrp2_impl::set_tx_fe_corrections, this, mb, _1)); + } + const fs_path db_rx_fe_path = mb_path / "dboards" / "A" / "rx_frontends"; + BOOST_FOREACH(const std::string &name, _tree->list(db_rx_fe_path)){ + _tree->access<double>(db_rx_fe_path / name / "freq" / "value") + .subscribe(boost::bind(&usrp2_impl::set_rx_fe_corrections, this, mb, _1)); + } } //initialize io handling @@ -653,6 +666,14 @@ sensor_value_t usrp2_impl::get_ref_locked(const std::string &mb){ return sensor_value_t("Ref", lock, "locked", "unlocked"); } +void usrp2_impl::set_rx_fe_corrections(const std::string &mb, const double lo_freq){ + apply_rx_fe_corrections(this->get_tree()->subtree("/mboards/" + mb), "A", lo_freq); +} + +void usrp2_impl::set_tx_fe_corrections(const std::string &mb, const double lo_freq){ + apply_tx_fe_corrections(this->get_tree()->subtree("/mboards/" + mb), "A", lo_freq); +} + #include <boost/math/special_functions/round.hpp> #include <boost/math/special_functions/sign.hpp> diff --git a/host/lib/usrp/usrp2/usrp2_impl.hpp b/host/lib/usrp/usrp2/usrp2_impl.hpp index 535397d84..278dc713e 100644 --- a/host/lib/usrp/usrp2/usrp2_impl.hpp +++ b/host/lib/usrp/usrp2/usrp2_impl.hpp @@ -106,6 +106,9 @@ private: uhd::sensor_value_t get_mimo_locked(const std::string &); uhd::sensor_value_t get_ref_locked(const std::string &); + void set_rx_fe_corrections(const std::string &mb, const double); + void set_tx_fe_corrections(const std::string &mb, const double); + //device properties interface uhd::property_tree::sptr get_tree(void) const{ return _tree; diff --git a/host/lib/utils/CMakeLists.txt b/host/lib/utils/CMakeLists.txt index 19dde9a56..b50e91299 100644 --- a/host/lib/utils/CMakeLists.txt +++ b/host/lib/utils/CMakeLists.txt @@ -128,6 +128,7 @@ SET_SOURCE_FILES_PROPERTIES( # Append sources ######################################################################## LIBUHD_APPEND_SOURCES( + ${CMAKE_CURRENT_SOURCE_DIR}/csv.cpp ${CMAKE_CURRENT_SOURCE_DIR}/gain_group.cpp ${CMAKE_CURRENT_SOURCE_DIR}/images.cpp ${CMAKE_CURRENT_SOURCE_DIR}/load_modules.cpp diff --git a/host/lib/utils/csv.cpp b/host/lib/utils/csv.cpp new file mode 100644 index 000000000..2ffa70196 --- /dev/null +++ b/host/lib/utils/csv.cpp @@ -0,0 +1,52 @@ +// +// Copyright 2011 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 <uhd/utils/csv.hpp> +#include <boost/foreach.hpp> + +using namespace uhd; + +csv::rows_type csv::to_rows(std::istream &input){ + csv::rows_type rows; + std::string line; + //for each line in the input stream + while (std::getline(input, line)){ + csv::row_type row(1, ""); + bool in_quote = false; + char last_ch, next_ch = ' '; + //for each character in the line + BOOST_FOREACH(char ch, line){ + last_ch = next_ch; + next_ch = ch; + //catch a quote character and change the state + //we handle double quotes by checking last_ch + if (ch == '"'){ + in_quote = not in_quote; + if (last_ch != '"') continue; + } + //a comma not inside quotes is a column delimiter + if (not in_quote and ch == ','){ + row.push_back(""); + continue; + } + //if we got here we record the character + row.back() += ch; + } + rows.push_back(row); + } + return rows; +} diff --git a/host/lib/utils/paths.cpp b/host/lib/utils/paths.cpp index a3dd377e5..4fc877d5d 100644 --- a/host/lib/utils/paths.cpp +++ b/host/lib/utils/paths.cpp @@ -16,6 +16,7 @@ // #include <uhd/config.hpp> +#include <uhd/utils/paths.hpp> #include <boost/tokenizer.hpp> #include <boost/filesystem.hpp> #include <boost/foreach.hpp> @@ -23,6 +24,8 @@ #include <cstdlib> #include <string> #include <vector> +#include <cstdlib> //getenv +#include <cstdio> //P_tmpdir namespace fs = boost::filesystem; @@ -79,3 +82,27 @@ std::vector<fs::path> get_module_paths(void){ paths.push_back(get_uhd_pkg_data_path() / "modules"); return paths; } + +/*********************************************************************** + * Implement the functions in paths.hpp + **********************************************************************/ +std::string uhd::get_tmp_path(void){ + const char *tmp_path = std::getenv("TMP"); + if (tmp_path != NULL) return tmp_path; + + #ifdef P_tmpdir + if (P_tmpdir != NULL) return P_tmpdir; + #endif + + return "/tmp"; +} + +std::string uhd::get_app_path(void){ + const char *appdata_path = std::getenv("APPDATA"); + if (appdata_path != NULL) return appdata_path; + + const char *home_path = std::getenv("HOME"); + if (home_path != NULL) return home_path; + + return uhd::get_tmp_path(); +} diff --git a/host/utils/CMakeLists.txt b/host/utils/CMakeLists.txt index 1a0396ad3..430b49c47 100644 --- a/host/utils/CMakeLists.txt +++ b/host/utils/CMakeLists.txt @@ -21,6 +21,9 @@ SET(util_runtime_sources uhd_find_devices.cpp uhd_usrp_probe.cpp + uhd_cal_rx_iq_balance.cpp + uhd_cal_tx_dc_offset.cpp + uhd_cal_tx_iq_balance.cpp ) #for each source: build an executable and install diff --git a/host/utils/uhd_cal_rx_iq_balance.cpp b/host/utils/uhd_cal_rx_iq_balance.cpp new file mode 100644 index 000000000..da9ccbdb3 --- /dev/null +++ b/host/utils/uhd_cal_rx_iq_balance.cpp @@ -0,0 +1,240 @@ +// +// 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 <cmath> +#include <ctime> + +namespace po = boost::program_options; + +/*********************************************************************** + * Transmit thread + **********************************************************************/ +static void tx_thread(uhd::usrp::multi_usrp::sptr usrp, 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); + + //fill buff and send until interrupted + while (not boost::this_thread::interruption_requested()){ + for (size_t i = 0; i < buff.size(); i++){ + buff[i] = float(tx_wave_ampl); + } + 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 rx_lo_freq, const double tx_offset){ + //tune the receiver with no cordic + uhd::tune_request_t rx_tune_req(rx_lo_freq); + rx_tune_req.dsp_freq_policy = uhd::tune_request_t::POLICY_MANUAL; + rx_tune_req.dsp_freq = 0; + usrp->set_rx_freq(rx_tune_req); + + //tune the transmitter with no cordic + uhd::tune_request_t tx_tune_req(usrp->get_rx_freq() - tx_offset); + 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); + + //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_rx_freq(); +} + +/*********************************************************************** + * Main + **********************************************************************/ +int UHD_SAFE_MAIN(int argc, char *argv[]){ + std::string args; + double tx_wave_ampl, tx_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_ampl", po::value<double>(&tx_wave_ampl)->default_value(0.7), "Transmit wave amplitude in counts") + ("tx_offset", po::value<double>(&tx_offset)->default_value(.9344e6), "TX LO offset from the RX 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 RX IQ Balance 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_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_rx_freq_range().start() + 50e6; + if (not vm.count("freq_stop")) freq_stop = usrp->get_rx_freq_range().stop() - 50e6; + + for (double rx_lo_i = freq_start; rx_lo_i <= freq_stop; rx_lo_i += freq_step){ + const double rx_lo = tune_rx_and_tx(usrp, rx_lo_i, tx_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_tone_freq = actual_tx_freq - actual_rx_freq; + const double bb_imag_freq = -bb_tone_freq; + + //capture initial uncorrected value + usrp->set_rx_iq_balance(std::polar<double>(1.0, 0.0)); + capture_samples(usrp, rx_stream, buff, nsamps); + const double initial_suppression = compute_tone_dbrms(buff, bb_tone_freq/actual_rx_rate) - compute_tone_dbrms(buff, bb_imag_freq/actual_rx_rate); + + //bounds and results from searching + std::complex<double> best_correction; + double phase_corr_start = -.3, phase_corr_stop = .3, phase_corr_step; + double ampl_corr_start = -.3, ampl_corr_stop = .3, ampl_corr_step; + double best_suppression = 0, best_phase_corr = 0, best_ampl_corr = 0; + + for (size_t i = 0; i < num_search_iters; i++){ + + phase_corr_step = (phase_corr_stop - phase_corr_start)/(num_search_steps-1); + ampl_corr_step = (ampl_corr_stop - ampl_corr_start)/(num_search_steps-1); + + for (double phase_corr = phase_corr_start; phase_corr <= phase_corr_stop + phase_corr_step/2; phase_corr += phase_corr_step){ + for (double ampl_corr = ampl_corr_start; ampl_corr <= ampl_corr_stop + ampl_corr_step/2; ampl_corr += ampl_corr_step){ + + const std::complex<double> correction = std::polar(ampl_corr+1, phase_corr*tau); + usrp->set_rx_iq_balance(correction); + + //receive some samples + capture_samples(usrp, rx_stream, buff, nsamps); + + const double tone_dbrms = compute_tone_dbrms(buff, bb_tone_freq/actual_rx_rate); + const double imag_dbrms = compute_tone_dbrms(buff, bb_imag_freq/actual_rx_rate); + const double suppression = tone_dbrms - imag_dbrms; + + if (suppression > best_suppression){ + best_correction = correction; + best_suppression = suppression; + best_phase_corr = phase_corr; + best_ampl_corr = ampl_corr; + } + + }} + + //std::cout << "best_phase_corr " << best_phase_corr << std::endl; + //std::cout << "best_ampl_corr " << best_ampl_corr << std::endl; + //std::cout << "best_suppression " << best_suppression << std::endl; + + phase_corr_start = best_phase_corr - phase_corr_step; + phase_corr_stop = best_phase_corr + phase_corr_step; + ampl_corr_start = best_ampl_corr - ampl_corr_step; + ampl_corr_stop = best_ampl_corr + ampl_corr_step; + } + + if (best_suppression > 30){ //most likely valid, keep result + result_t result; + result.freq = rx_lo; + result.real_corr = best_correction.real(); + result.imag_corr = best_correction.imag(); + result.best = best_suppression; + result.delta = best_suppression - initial_suppression; + results.push_back(result); + if (vm.count("verbose")){ + std::cout << boost::format("RX IQ: %f MHz: best suppression %f dB, corrected %f dB") % (rx_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, "RX", "rx", "iq"); + + return 0; +} diff --git a/host/utils/uhd_cal_tx_dc_offset.cpp b/host/utils/uhd_cal_tx_dc_offset.cpp new file mode 100644 index 000000000..af5b60d14 --- /dev/null +++ b/host/utils/uhd_cal_tx_dc_offset.cpp @@ -0,0 +1,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; +} diff --git a/host/utils/uhd_cal_tx_iq_balance.cpp b/host/utils/uhd_cal_tx_iq_balance.cpp new file mode 100644 index 000000000..ff965e040 --- /dev/null +++ b/host/utils/uhd_cal_tx_iq_balance.cpp @@ -0,0 +1,243 @@ +// +// 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 IQ Balance 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_tone_freq = actual_tx_freq + tx_wave_freq - actual_rx_freq; + const double bb_imag_freq = actual_tx_freq - tx_wave_freq - actual_rx_freq; + + //capture initial uncorrected value + usrp->set_tx_iq_balance(std::polar<double>(1.0, 0.0)); + capture_samples(usrp, rx_stream, buff, nsamps); + const double initial_suppression = compute_tone_dbrms(buff, bb_tone_freq/actual_rx_rate) - compute_tone_dbrms(buff, bb_imag_freq/actual_rx_rate); + + //bounds and results from searching + std::complex<double> best_correction; + double phase_corr_start = -.3, phase_corr_stop = .3, phase_corr_step; + double ampl_corr_start = -.3, ampl_corr_stop = .3, ampl_corr_step; + double best_suppression = 0, best_phase_corr = 0, best_ampl_corr = 0; + + for (size_t i = 0; i < num_search_iters; i++){ + + phase_corr_step = (phase_corr_stop - phase_corr_start)/(num_search_steps-1); + ampl_corr_step = (ampl_corr_stop - ampl_corr_start)/(num_search_steps-1); + + for (double phase_corr = phase_corr_start; phase_corr <= phase_corr_stop + phase_corr_step/2; phase_corr += phase_corr_step){ + for (double ampl_corr = ampl_corr_start; ampl_corr <= ampl_corr_stop + ampl_corr_step/2; ampl_corr += ampl_corr_step){ + + const std::complex<double> correction = std::polar(ampl_corr+1, phase_corr*tau); + usrp->set_tx_iq_balance(correction); + + //receive some samples + capture_samples(usrp, rx_stream, buff, nsamps); + + const double tone_dbrms = compute_tone_dbrms(buff, bb_tone_freq/actual_rx_rate); + const double imag_dbrms = compute_tone_dbrms(buff, bb_imag_freq/actual_rx_rate); + const double suppression = tone_dbrms - imag_dbrms; + + if (suppression > best_suppression){ + best_correction = correction; + best_suppression = suppression; + best_phase_corr = phase_corr; + best_ampl_corr = ampl_corr; + } + + }} + + //std::cout << "best_phase_corr " << best_phase_corr << std::endl; + //std::cout << "best_ampl_corr " << best_ampl_corr << std::endl; + //std::cout << "best_suppression " << best_suppression << std::endl; + + phase_corr_start = best_phase_corr - phase_corr_step; + phase_corr_stop = best_phase_corr + phase_corr_step; + ampl_corr_start = best_ampl_corr - ampl_corr_step; + ampl_corr_stop = best_ampl_corr + ampl_corr_step; + } + + if (best_suppression > 30){ //most likely valid, keep result + result_t result; + result.freq = tx_lo; + result.real_corr = best_correction.real(); + result.imag_corr = best_correction.imag(); + result.best = best_suppression; + result.delta = best_suppression - initial_suppression; + results.push_back(result); + if (vm.count("verbose")){ + std::cout << boost::format("TX IQ: %f MHz: best suppression %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", "iq"); + + return 0; +} diff --git a/host/utils/usrp_cal_utils.hpp b/host/utils/usrp_cal_utils.hpp new file mode 100644 index 000000000..0faaf9a84 --- /dev/null +++ b/host/utils/usrp_cal_utils.hpp @@ -0,0 +1,225 @@ +// +// 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 <uhd/utils/paths.hpp> +#include <uhd/property_tree.hpp> +#include <uhd/usrp/multi_usrp.hpp> +#include <uhd/usrp/dboard_eeprom.hpp> +#include <boost/filesystem.hpp> +#include <iostream> +#include <vector> +#include <complex> +#include <cmath> +#include <fstream> + +namespace fs = boost::filesystem; + +struct result_t{double freq, real_corr, imag_corr, best, delta;}; + +/*********************************************************************** + * Constants + **********************************************************************/ +static const double tau = 6.28318531; +static const double alpha = 0.0001; //very tight iir filter +static const size_t wave_table_len = 8192; +static const size_t num_search_steps = 5; +static const size_t num_search_iters = 7; +static const size_t skip_initial_samps = 20; +static const double default_freq_step = 7.3e6; +static const size_t default_num_samps = 10000; + +/*********************************************************************** + * Set standard defaults for devices + **********************************************************************/ +static inline void set_optimum_defaults(uhd::usrp::multi_usrp::sptr usrp){ + uhd::property_tree::sptr tree = usrp->get_device()->get_tree(); + + const uhd::fs_path mb_path = "/mboards/0"; + const std::string mb_name = tree->access<std::string>(mb_path / "name").get(); + if (mb_name.find("USRP2") != std::string::npos){ + usrp->set_tx_rate(12.5e6); + usrp->set_rx_rate(12.5e6); + } + else if (mb_name.find("B100") != std::string::npos){ + usrp->set_tx_rate(4e6); + usrp->set_rx_rate(4e6); + } + else if (mb_name.find("E10") != std::string::npos){ + usrp->set_tx_rate(4e6); + usrp->set_rx_rate(8e6); + } + else{ + throw std::runtime_error("self-calibration is not supported for this hardware"); + } + + const uhd::fs_path tx_fe_path = "/mboards/0/dboards/A/tx_frontends/0"; + const std::string tx_name = tree->access<std::string>(tx_fe_path / "name").get(); + if (tx_name.find("WBX") != std::string::npos or tx_name.find("SBX") != std::string::npos){ + usrp->set_tx_gain(0); + } + else{ + throw std::runtime_error("self-calibration is not supported for this hardware"); + } + + const uhd::fs_path rx_fe_path = "/mboards/0/dboards/A/tx_frontends/0"; + const std::string rx_name = tree->access<std::string>(rx_fe_path / "name").get(); + if (rx_name.find("WBX") != std::string::npos or rx_name.find("SBX") != std::string::npos){ + usrp->set_rx_gain(25); + } + else{ + throw std::runtime_error("self-calibration is not supported for this hardware"); + } + +} + +/*********************************************************************** + * Sinusoid wave table + **********************************************************************/ +class wave_table{ +public: + wave_table(const double ampl){ + _table.resize(wave_table_len); + for (size_t i = 0; i < wave_table_len; i++){ + _table[i] = std::complex<float>(std::polar(ampl, (tau*i)/wave_table_len)); + } + } + + inline std::complex<float> operator()(const size_t index) const{ + return _table[index % wave_table_len]; + } + +private: + std::vector<std::complex<float> > _table; +}; + +/*********************************************************************** + * Compute power of a tone + **********************************************************************/ +static inline double compute_tone_dbrms( + const std::vector<std::complex<float> > &samples, + const double freq //freq is fractional +){ + //shift the samples so the tone at freq is down at DC + std::vector<std::complex<float> > shifted(samples.size() - skip_initial_samps); + for (size_t i = 0; i < shifted.size(); i++){ + shifted[i] = samples[i+skip_initial_samps] * std::complex<float>(std::polar(1.0, -freq*tau*i)); + } + + //filter the samples with a narrow low pass + std::complex<float> iir_output = 0, iir_last = 0; + double output = 0; + for (size_t i = 0; i < shifted.size(); i++){ + iir_output = float(alpha) * shifted[i] + float(1-alpha)*iir_last; + iir_last = iir_output; + output += std::abs(iir_output); + } + + return 20*std::log10(output/shifted.size()); +} + +/*********************************************************************** + * Write a dat file + **********************************************************************/ +static inline void write_samples_to_file( + const std::vector<std::complex<float> > &samples, const std::string &file +){ + std::ofstream outfile(file.c_str(), std::ofstream::binary); + outfile.write((const char*)&samples.front(), samples.size()*sizeof(std::complex<float>)); + outfile.close(); +} + +/*********************************************************************** + * Store data to file + **********************************************************************/ +static void store_results( + uhd::usrp::multi_usrp::sptr usrp, + const std::vector<result_t> &results, + const std::string &XX, + const std::string &xx, + const std::string &what +){ + //extract eeprom serial + uhd::property_tree::sptr tree = usrp->get_device()->get_tree(); + const uhd::fs_path db_path = "/mboards/0/dboards/A/" + xx + "_eeprom"; + const uhd::usrp::dboard_eeprom_t db_eeprom = tree->access<uhd::usrp::dboard_eeprom_t>(db_path).get(); + if (db_eeprom.serial.empty()) throw std::runtime_error(XX + " dboard has empty serial!"); + + //make the calibration file path + fs::path cal_data_path = fs::path(uhd::get_app_path()) / ".uhd"; + fs::create_directory(cal_data_path); + cal_data_path = cal_data_path / "cal"; + fs::create_directory(cal_data_path); + cal_data_path = cal_data_path / str(boost::format("%s_%s_cal_v0.1_%s.csv") % xx % what % db_eeprom.serial); + if (fs::exists(cal_data_path)){ + fs::rename(cal_data_path, cal_data_path.string() + str(boost::format(".%d") % time(NULL))); + } + + //fill the calibration file + std::ofstream cal_data(cal_data_path.string().c_str()); + cal_data << boost::format("name, %s Frontend Calibration\n") % XX; + cal_data << boost::format("serial, %s\n") % db_eeprom.serial; + cal_data << boost::format("timestamp, %d\n") % time(NULL); + cal_data << boost::format("version, 0, 1\n"); + cal_data << boost::format("DATA STARTS HERE\n"); + cal_data << "lo_frequency, correction_real, correction_imag, measured, delta\n"; + + for (size_t i = 0; i < results.size(); i++){ + cal_data + << results[i].freq << ", " + << results[i].real_corr << ", " + << results[i].imag_corr << ", " + << results[i].best << ", " + << results[i].delta << "\n" + ; + } + + std::cout << "wrote cal data to " << cal_data_path << std::endl; +} + +/*********************************************************************** + * Data capture routine + **********************************************************************/ +static void capture_samples( + uhd::usrp::multi_usrp::sptr usrp, + uhd::rx_streamer::sptr rx_stream, + std::vector<std::complex<float> > &buff, + const size_t nsamps_requested +){ + buff.resize(nsamps_requested); + uhd::rx_metadata_t md; + + uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); + stream_cmd.num_samps = buff.size(); + stream_cmd.stream_now = true; + usrp->issue_stream_cmd(stream_cmd); + const size_t num_rx_samps = rx_stream->recv(&buff.front(), buff.size(), md); + + //validate the received data + if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE){ + throw std::runtime_error(str(boost::format( + "Unexpected error code 0x%x" + ) % md.error_code)); + } + //we can live if all the data didnt come in + if (num_rx_samps > buff.size()/2){ + buff.resize(num_rx_samps); + return; + } + if (num_rx_samps != buff.size()){ + throw std::runtime_error("did not get all the samples requested"); + } +} |