uhd

#include <algorithm>

#include <boost/range/begin.hpp>

#include <boost/range/end.hpp>

 * Useful templated functions and classes that I like to pretend are part of stl.

 * Many of the range wrapper functions come with recent versions of boost (1.43).

 */

    /*!

     * A wrapper around std::sort that takes a range instead of an iterator.

     * \return a new range with the elements sorted

     */

    template<typename Range> inline Range sorted(const Range &range){

    }

    /*!

     * \return a new range with the elements reversed

     */

    template<typename Range> inline Range reversed(const Range &range){

    }

    /*!

    }

    /*!

     * A templated clip implementation.

     * \param val the value to clip between an upper and lower limit

     * \param bound1 the upper or lower bound

        return val;

    }

#endif /* INCLUDED_UHD_UTILS_ALGORITHM_HPP */

        const T &value,

        const std::string &what

    ){

        std::string possible_values = "";

        size_t i = 0;

        BOOST_FOREACH(const T &v, range){

){

    //combine the hashes of sorted keys/value pairs

    size_t hash = 0;

        boost::hash_combine(hash, key);

        boost::hash_combine(hash, dev_addr[key]);

    }

    void set_bandwidth(double bandwidth);

    void send_reg(boost::uint8_t start_reg, boost::uint8_t stop_reg){

        for(boost::uint8_t start_addr=start_reg; start_addr <= stop_reg; start_addr += sizeof(boost::uint32_t) - 1){

            int num_bytes = int(stop_reg - start_addr + 1) > int(sizeof(boost::uint32_t)) - 1 ? sizeof(boost::uint32_t) - 1 : stop_reg - start_addr + 1;

    void read_reg(boost::uint8_t start_reg, boost::uint8_t stop_reg){

        static const boost::uint8_t status_addr = 0x0;

        for(boost::uint8_t start_addr=start_reg; start_addr <= stop_reg; start_addr += sizeof(boost::uint32_t)){

            int num_bytes = int(stop_reg - start_addr + 1) > int(sizeof(boost::uint32_t)) ? sizeof(boost::uint32_t) : stop_reg - start_addr + 1;

    bool update_filter_settings = false;

    //choose refclock

    std::vector<double> clock_rates = this->get_iface()->get_clock_rates(dboard_iface::UNIT_RX);

        if (ref_clock > 27.0e6) continue;

        if (size_t(max_clock_rate/ref_clock)%2 == 1) continue; //reject asymmetric clocks (odd divisors)

 **********************************************************************/

void dbsrx::set_bandwidth(double bandwidth){

    //clip the input

    double ref_clock = this->get_iface()->get_clock_rate(dboard_iface::UNIT_RX);

    //NOTE: _max2118_write_regs.m_divider set in set_lo_freq

    //compute f_dac setting

    //determine actual bandwidth

    _bandwidth = double((ref_clock/(_max2118_write_regs.m_divider))*(4+0.145*_max2118_write_regs.f_dac));

    void set_bandwidth(double bandwidth);

    void send_reg(boost::uint8_t start_reg, boost::uint8_t stop_reg){

        for(boost::uint8_t start_addr=start_reg; start_addr <= stop_reg; start_addr += sizeof(boost::uint32_t) - 1){

            int num_bytes = int(stop_reg - start_addr + 1) > int(sizeof(boost::uint32_t)) - 1 ? sizeof(boost::uint32_t) - 1 : stop_reg - start_addr + 1;

    void read_reg(boost::uint8_t start_reg, boost::uint8_t stop_reg){

        static const boost::uint8_t status_addr = 0xC;

        for(boost::uint8_t start_addr=start_reg; start_addr <= stop_reg; start_addr += sizeof(boost::uint32_t)){

            int num_bytes = int(stop_reg - start_addr + 1) > int(sizeof(boost::uint32_t)) ? sizeof(boost::uint32_t) : stop_reg - start_addr + 1;

 * Tuning

 **********************************************************************/

void dbsrx2::set_lo_freq(double target_freq){

    //variables used in the calculation below

    int scaler = target_freq > 1125e6 ? 2 : 4;

 **********************************************************************/

void dbsrx2::set_bandwidth(double bandwidth){

    //clip the input

    _max2112_write_regs.lp = int((bandwidth/1e6 - 4)/0.29 + 12);

    _bandwidth = double(4 + (_max2112_write_regs.lp - 12) * 0.29)*1e6;

    static const double slope = (max_volts-min_volts)/(range);

    //calculate the voltage for the aux dac

    //the actual gain setting

    gain = (dac_volts - min_volts)/slope;

static double gain_interp(double gain, boost::array<double, 17> db_vector, boost::array<double, 17> volts_vector) {

    double volts;

    boost::uint8_t gain_step = 0;

    //find which bin we're in

    //this is the voltage at the USRP DAC output

    double dac_volts = gain_volts / opamp_gain;

    if (tvrx_debug) std::cerr << boost::format(

        "tvrx RF AGC gain: %f dB, dac_volts: %f V"

    double gain_volts = gain_interp(gain, tvrx_if_gains_db, tvrx_gains_volts);

    double dac_volts = gain_volts / opamp_gain;

    if (tvrx_debug) std::cerr << boost::format(

        "tvrx IF AGC gain: %f dB, dac_volts: %f V"

 */

static int gain_to_tx_vga_reg(double &gain){

    //calculate the register value

    //calculate the actual gain value

    if (reg < 4)       gain = 0;

 * \return gain enum value

 */

static max2829_regs_t::tx_baseband_gain_t gain_to_tx_bb_reg(double &gain){

    switch(reg){

    case 0:

        gain = 0;

 * \return 5 bit the register value

 */

static int gain_to_rx_vga_reg(double &gain){

    gain = double(reg*2);

    return reg;

}

 * \return 2 bit the register value

 */

static int gain_to_rx_lna_reg(double &gain){

    switch(reg){

    case 0:

    case 1: gain = 0;    break;

 * Bandwidth Handling

 **********************************************************************/

static max2829_regs_t::tx_lpf_coarse_adj_t bandwidth_to_tx_lpf_coarse_reg(double &bandwidth){

    switch(reg){

    case 1: // bandwidth < 15MHz

}

static max2829_regs_t::rx_lpf_fine_adj_t bandwidth_to_rx_lpf_fine_reg(double &bandwidth, double requested_bandwidth){

    switch(reg){

    case 18: // requested_bandwidth < 92.5%

}

static max2829_regs_t::rx_lpf_coarse_adj_t bandwidth_to_rx_lpf_coarse_reg(double &bandwidth){

    switch(reg){

    case 0: // bandwidth < 7.5MHz

        wax::obj dboard = mboard[named_prop_t(dboard_prop, db_name)];

        BOOST_FOREACH(const std::string &sd_name, dboard[DBOARD_PROP_SUBDEV_NAMES].as<prop_names_t>()){

            try{

                dboard[named_prop_t(DBOARD_PROP_SUBDEV, sd_name)][SUBDEV_PROP_ENABLED] = enable;

            }

            catch(const std::exception &e){

void usrp1_codec_ctrl_impl::set_tx_pga_gain(double gain){

    int gain_word = int(mtpgw*(gain - tx_pga_gain_range.start())/(tx_pga_gain_range.stop() - tx_pga_gain_range.start()));

    this->send_reg(16);

}

void usrp1_codec_ctrl_impl::set_rx_pga_gain(double gain, char which){

    int gain_word = int(mrpgw*(gain - rx_pga_gain_range.start())/(rx_pga_gain_range.stop() - rx_pga_gain_range.start()));

    switch(which){

    case 'A':

        _ad9862_regs.rx_pga_a = gain_word;

{

    //special case for aux dac d (aka sigma delta word)

    if (which == AUX_DAC_D) {

        _ad9862_regs.sig_delt_11_4 = boost::uint8_t(dac_word >> 4);

        _ad9862_regs.sig_delt_3_0 = boost::uint8_t(dac_word & 0xf);

        this->send_reg(42);

    }

    //calculate the dac word for aux dac a, b, c

    //setup a lookup table for the aux dac params (reg ref, reg addr)

    typedef boost::tuple<boost::uint8_t*, boost::uint8_t> dac_params_t;

void usrp_e100_codec_ctrl_impl::set_tx_pga_gain(double gain){

    int gain_word = int(mtpgw*(gain - tx_pga_gain_range.start())/(tx_pga_gain_range.stop() - tx_pga_gain_range.start()));

    this->send_reg(16);

}

void usrp_e100_codec_ctrl_impl::set_rx_pga_gain(double gain, char which){

    int gain_word = int(mrpgw*(gain - rx_pga_gain_range.start())/(rx_pga_gain_range.stop() - rx_pga_gain_range.start()));

    switch(which){

    case 'A':

        _ad9862_regs.rx_pga_a = gain_word;

void usrp_e100_codec_ctrl_impl::write_aux_dac(aux_dac_t which, double volts){

    //special case for aux dac d (aka sigma delta word)

    if (which == AUX_DAC_D){

        _ad9862_regs.sig_delt_11_4 = boost::uint8_t(dac_word >> 4);

        _ad9862_regs.sig_delt_3_0 = boost::uint8_t(dac_word & 0xf);

        this->send_reg(42);

    }

    //calculate the dac word for aux dac a, b, c

    //setup a lookup table for the aux dac params (reg ref, reg addr)

    typedef boost::tuple<boost::uint8_t*, boost::uint8_t> dac_params_t;

        double gain_left_to_distribute = gain;

        BOOST_FOREACH(const gain_fcns_t &fcns, all_fcns){

            const gain_range_t range = fcns.get_range();

                gain_left_to_distribute, range.start(), range.stop()

            ), max_step));

            gain_left_to_distribute -= gain_bucket.back();

        //fill in the largest step sizes first that are less than the remainder

        BOOST_FOREACH(size_t i, indexes_step_size_dec){

            const gain_range_t range = all_fcns.at(i).get_range();

                gain_bucket.at(i) + gain_left_to_distribute, range.start(), range.stop()

            ), range.step()) - gain_bucket.at(i);

            gain_bucket.at(i) += additional_gain;

    //! get the gain function sets in order (highest priority first)

    std::vector<gain_fcns_t> get_all_fcns(void){

        std::vector<gain_fcns_t> all_fcns;

            const std::vector<gain_fcns_t> &fcns = _registry[key];

            all_fcns.insert(all_fcns.begin(), fcns.begin(), fcns.end());

        }

    vec.push_back(3);

    vec.push_back(5);

    std::cout << "The output of the assert_has error:" << std::endl;

    try{