saymrwulf/uhd
1
0
Fork 0
mirror of https://github.com/saymrwulf/uhd.git synced 2026-05-16 21:10:10 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
uhd/host/lib/usrp/dboard/db_wbx_version2.cpp
Martin Braun 876d4150aa uhd: Apply clang-format against all .cpp and .hpp files in host/ 
Note: template_lvbitx.{cpp,hpp} need to be excluded from the list of
files that clang-format gets applied against.
2020-03-03 08:51:32 -06:00

268 lines
11 KiB
C++
Raw Blame History

//
// Copyright 2011-2014 Ettus Research LLC
// Copyright 2018 Ettus Research, a National Instruments Company
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
#include "db_wbx_common.hpp"
#include <uhd/types/dict.hpp>
#include <uhd/types/ranges.hpp>
#include <uhd/types/sensors.hpp>
#include <uhd/types/tune_request.hpp>
#include <uhd/usrp/dboard_base.hpp>
#include <uhd/utils/algorithm.hpp>
#include <uhd/utils/assert_has.hpp>
#include <uhd/utils/log.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/format.hpp>
#include <boost/math/special_functions/round.hpp>
#include <functional>
using namespace uhd;
using namespace uhd::usrp;
using namespace boost::assign;
/***********************************************************************
* WBX Version 2 Constants
**********************************************************************/
static const uhd::dict<std::string, gain_range_t> wbx_v2_tx_gain_ranges =
map_list_of("PGA0", gain_range_t(0, 25, 0.05));
static const freq_range_t wbx_v2_freq_range(68.75e6, 2.2e9);
/***********************************************************************
* Gain-related functions
**********************************************************************/
static double tx_pga0_gain_to_dac_volts(double& gain)
{
// clip the input
gain = wbx_v2_tx_gain_ranges["PGA0"].clip(gain);
// voltage level constants
static const double max_volts = 0.5, min_volts = 1.4;
static const double slope =
(max_volts - min_volts) / wbx_v2_tx_gain_ranges["PGA0"].stop();
// calculate the voltage for the aux dac
double dac_volts = gain * slope + min_volts;
UHD_LOGGER_TRACE("WBX") << boost::format("WBX TX Gain: %f dB, dac_volts: %f V") % gain
% dac_volts;
// the actual gain setting
gain = (dac_volts - min_volts) / slope;
return dac_volts;
}
/***********************************************************************
* WBX Version 2 Implementation
**********************************************************************/
wbx_base::wbx_version2::wbx_version2(wbx_base* _self_wbx_base)
{
// register our handle on the primary wbx_base instance
self_base = _self_wbx_base;
_txlo = adf435x_iface::make_adf4350(std::bind(&wbx_base::wbx_versionx::write_lo_regs,
this,
dboard_iface::UNIT_TX,
std::placeholders::_1));
_rxlo = adf435x_iface::make_adf4350(std::bind(&wbx_base::wbx_versionx::write_lo_regs,
this,
dboard_iface::UNIT_RX,
std::placeholders::_1));
////////////////////////////////////////////////////////////////////
// Register RX properties
////////////////////////////////////////////////////////////////////
this->get_rx_subtree()->create<std::string>("name").set("WBXv2 RX");
this->get_rx_subtree()
->create<double>("freq/value")
.set_coercer(std::bind(&wbx_base::wbx_version2::set_lo_freq,
this,
dboard_iface::UNIT_RX,
std::placeholders::_1))
.set((wbx_v2_freq_range.start() + wbx_v2_freq_range.stop()) / 2.0);
this->get_rx_subtree()->create<meta_range_t>("freq/range").set(wbx_v2_freq_range);
////////////////////////////////////////////////////////////////////
// Register TX properties
////////////////////////////////////////////////////////////////////
this->get_tx_subtree()->create<std::string>("name").set("WBXv2 TX");
for (const std::string& name : wbx_v2_tx_gain_ranges.keys()) {
self_base->get_tx_subtree()
->create<double>("gains/" + name + "/value")
.set_coercer(std::bind(
&wbx_base::wbx_version2::set_tx_gain, this, std::placeholders::_1, name))
.set(wbx_v2_tx_gain_ranges[name].start());
self_base->get_tx_subtree()
->create<meta_range_t>("gains/" + name + "/range")
.set(wbx_v2_tx_gain_ranges[name]);
}
this->get_tx_subtree()
->create<double>("freq/value")
.set_coercer(std::bind(&wbx_base::wbx_version2::set_lo_freq,
this,
dboard_iface::UNIT_TX,
std::placeholders::_1))
.set((wbx_v2_freq_range.start() + wbx_v2_freq_range.stop()) / 2.0);
this->get_tx_subtree()->create<meta_range_t>("freq/range").set(wbx_v2_freq_range);
this->get_tx_subtree()
->create<bool>("enabled")
.add_coerced_subscriber(std::bind(
&wbx_base::wbx_version2::set_tx_enabled, this, std::placeholders::_1))
.set(true); // start enabled
// set attenuator control bits
int v2_iobits = ADF435X_CE;
int v2_tx_mod = TXMOD_EN | ADF435X_PDBRF;
// set the gpio directions and atr controls
self_base->get_iface()->set_pin_ctrl(dboard_iface::UNIT_TX, v2_tx_mod);
self_base->get_iface()->set_pin_ctrl(dboard_iface::UNIT_RX, RXBB_PDB | ADF435X_PDBRF);
self_base->get_iface()->set_gpio_ddr(
dboard_iface::UNIT_TX, TX_PUP_5V | TX_PUP_3V | v2_tx_mod | v2_iobits);
self_base->get_iface()->set_gpio_ddr(dboard_iface::UNIT_RX,
RX_PUP_5V | RX_PUP_3V | ADF435X_CE | RXBB_PDB | ADF435X_PDBRF | RX_ATTN_MASK);
// setup ATR for the mixer enables (always enabled to prevent phase slip between
// bursts)
self_base->get_iface()->set_atr_reg(dboard_iface::UNIT_TX,
gpio_atr::ATR_REG_IDLE,
v2_tx_mod,
TX_MIXER_DIS | v2_tx_mod);
self_base->get_iface()->set_atr_reg(dboard_iface::UNIT_TX,
gpio_atr::ATR_REG_RX_ONLY,
v2_tx_mod,
TX_MIXER_DIS | v2_tx_mod);
self_base->get_iface()->set_atr_reg(dboard_iface::UNIT_TX,
gpio_atr::ATR_REG_TX_ONLY,
v2_tx_mod,
TX_MIXER_DIS | v2_tx_mod);
self_base->get_iface()->set_atr_reg(dboard_iface::UNIT_TX,
gpio_atr::ATR_REG_FULL_DUPLEX,
v2_tx_mod,
TX_MIXER_DIS | v2_tx_mod);
self_base->get_iface()->set_atr_reg(dboard_iface::UNIT_RX,
gpio_atr::ATR_REG_IDLE,
RX_MIXER_ENB,
RX_MIXER_DIS | RX_MIXER_ENB);
self_base->get_iface()->set_atr_reg(dboard_iface::UNIT_RX,
gpio_atr::ATR_REG_TX_ONLY,
RX_MIXER_ENB,
RX_MIXER_DIS | RX_MIXER_ENB);
self_base->get_iface()->set_atr_reg(dboard_iface::UNIT_RX,
gpio_atr::ATR_REG_RX_ONLY,
RX_MIXER_ENB,
RX_MIXER_DIS | RX_MIXER_ENB);
self_base->get_iface()->set_atr_reg(dboard_iface::UNIT_RX,
gpio_atr::ATR_REG_FULL_DUPLEX,
RX_MIXER_ENB,
RX_MIXER_DIS | RX_MIXER_ENB);
}
wbx_base::wbx_version2::~wbx_version2(void)
{
/* NOP */
}
/***********************************************************************
* Enables
**********************************************************************/
void wbx_base::wbx_version2::set_tx_enabled(bool enb)
{
self_base->get_iface()->set_gpio_out(dboard_iface::UNIT_TX,
(enb) ? TX_POWER_UP | ADF435X_CE : TX_POWER_DOWN,
TX_POWER_UP | TX_POWER_DOWN | ADF435X_CE);
}
/***********************************************************************
* Gain Handling
**********************************************************************/
double wbx_base::wbx_version2::set_tx_gain(double gain, const std::string& name)
{
assert_has(wbx_v2_tx_gain_ranges.keys(), name, "wbx tx gain name");
if (name == "PGA0") {
double dac_volts = tx_pga0_gain_to_dac_volts(gain);
self_base->_tx_gains[name] = gain;
// write the new voltage to the aux dac
self_base->get_iface()->write_aux_dac(
dboard_iface::UNIT_TX, dboard_iface::AUX_DAC_A, dac_volts);
} else
UHD_THROW_INVALID_CODE_PATH();
return self_base->_tx_gains[name]; // shadowed
}
/***********************************************************************
* Tuning
**********************************************************************/
double wbx_base::wbx_version2::set_lo_freq(dboard_iface::unit_t unit, double target_freq)
{
// clip to tuning range
target_freq = wbx_v2_freq_range.clip(target_freq);
UHD_LOGGER_TRACE("WBX") << boost::format("WBX tune: target frequency %f MHz")
% (target_freq / 1e6);
/*
* If the user sets 'mode_n=integer' in the tuning args, the user wishes to
* tune in Integer-N mode, which can result in better spur
* performance on some mixers. The default is fractional tuning.
*/
property_tree::sptr subtree = (unit == dboard_iface::UNIT_RX)
? self_base->get_rx_subtree()
: self_base->get_tx_subtree();
device_addr_t tune_args = subtree->access<device_addr_t>("tune_args").get();
bool is_int_n = boost::iequals(tune_args.get("mode_n", ""), "integer");
double reference_freq = self_base->get_iface()->get_clock_rate(unit);
// Select the LO
adf435x_iface::sptr& lo_iface = unit == dboard_iface::UNIT_RX ? _rxlo : _txlo;
lo_iface->set_reference_freq(reference_freq);
// The mixer has a divide-by-2 stage on the LO port so the synthesizer
// frequency must 2x the target frequency
double synth_target_freq = target_freq * 2;
// Use 8/9 prescaler for vco_freq > 3 GHz (pg.18 prescaler)
lo_iface->set_prescaler(synth_target_freq > 3e9 ? adf435x_iface::PRESCALER_8_9
: adf435x_iface::PRESCALER_4_5);
// The feedback of the divided frequency must be disabled whenever the target
// frequency divided by the minimum PFD frequency cannot meet the minimum integer
// divider (N) value. If it is disabled, additional phase ambiguity will be
// introduced. With a minimum PFD frequency of 10 MHz, synthesizer frequencies below
// 230 MHz (LO frequencies below 115 MHz) will have too much ambiguity to synchronize.
lo_iface->set_feedback_select(
(int(synth_target_freq / 10e6) >= lo_iface->get_int_range().start()
? adf435x_iface::FB_SEL_DIVIDED
: adf435x_iface::FB_SEL_FUNDAMENTAL));
double synth_actual_freq = lo_iface->set_frequency(synth_target_freq, is_int_n);
// The mixer has a divide-by-2 stage on the LO port so the synthesizer
// actual_freq must /2 the synth_actual_freq
double actual_freq = synth_actual_freq / 2;
if (unit == dboard_iface::UNIT_RX) {
lo_iface->set_output_power((actual_freq == wbx_rx_lo_5dbm.clip(actual_freq))
? adf435x_iface::OUTPUT_POWER_5DBM
: adf435x_iface::OUTPUT_POWER_2DBM);
} else {
lo_iface->set_output_power((actual_freq == wbx_tx_lo_5dbm.clip(actual_freq))
? adf435x_iface::OUTPUT_POWER_5DBM
: adf435x_iface::OUTPUT_POWER_M1DBM);
}
// Write to hardware
lo_iface->commit();
return actual_freq;
}
Reference in a new issue View git blame Copy permalink