USRPCtrl.hxx

Go to the documentation of this file.

#pragma once
 
/*
Copyright (c) 2012, 2026 Matthew H. Reilly (kb1vc)
All rights reserved.
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
 
    Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
    Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in
    the documentation and/or other materials provided with the
    distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

 
#include "SoDaBase.hxx"
#include "SoDaThread.hxx"
#include "Command.hxx"
#include "Params.hxx"
#include "USRPTRControl.hxx"
#include "RadioControl.hxx"
#include "USRPPropTree.hxx"
#include <uhd/version.hpp>
#include <uhd/utils/thread.hpp>
 
#include <uhd/utils/safe_main.hpp>
#include <uhd/usrp/multi_usrp.hpp>
#include <uhd/usrp/dboard_base.hpp>
#include <uhd/types/tune_request.hpp>
#include <uhd/types/tune_result.hpp>
 
#include <SoDa/MailBox.hxx>
 
#include <memory>
 
namespace SoDa {
  class USRPCtrl;
  typedef std::shared_ptr<USRPCtrl> USRPCtrlPtr;
  
  class USRPCtrl : public SoDa::RadioControl {
  protected:
    USRPCtrl(ParamsPtr params);
 
  public:
    static USRPCtrlPtr make(ParamsPtr params) {
      auto ret = std::shared_ptr<USRPCtrl>(new USRPCtrl(params));
      ret->self = ret;
      ret->registerThread(ret);
      return ret;
    }
    
    uhd::usrp::multi_usrp::sptr getUSRP() { return usrp; }

    bool isLOLocked(SoDa::RXTX rxtx);

    double setLOFreq(double freq, SoDa::RXTX rxtx);
 
    double getLOFreq(SoDa::RXTX rxtx);

    float setRFGain(float gain, SoDa::RXTX rxtx);

    void setSampleRate(float rate, SoDa::RXTX rxtx);

    float getSampleRate(SoDa::RXTX rxtx);
    
    
    std::string getHardwareDescription();

    bool setClockSource(Command::ClockSource src);
    
    
    Command::ClockSource getClockSource();

    RadioControlPtr getSelfPtr() { return self.lock(); }
 
    void setTXEna(bool enable, bool full_duplex) override {
      tx_on = enable;   // update RadioControl::tx_on so setRFGain(TX) guard works
      locSetTXEna(enable);
    }
    
  protected:
    ParamsPtr params;

    bool is_B2xx;
    bool is_B210; 
 

    uhd::tune_result_t checkLock(uhd::tune_request_t & req,
                 char sel,
                 uhd::tune_result_t & cur);

    std::vector<std::string> listAntennas(SoDa::RXTX rxtx);
 
 
    
    void setAntenna(const std::string & ant, SoDa::RXTX rxtx);

    std::string getAntenna(SoDa::RXTX rxtx);
 
    
 
  private:
 
    // USRP stuff.
    uhd::usrp::multi_usrp::sptr usrp; 
    uhd::usrp::dboard_iface::sptr dboard;  
    // need this for TX/RX enable.
    SoDa::USRPPropTree * tx_fe_subtree; 
    // need this for TX/RX enable.
    SoDa::USRPPropTree * rx_fe_subtree; 
 
    // what controls and widgets do we have for the two front-ends? 
 
    bool tx_fe_has_enable; 
    bool rx_fe_has_enable; 
    bool tx_has_lo_locked_sensor; 
    bool rx_has_lo_locked_sensor; 
 
 
    // Capability Flags --
    bool supports_tx_gpio; 
    
    // parallel IO to turn on RX ena and TX ena
    // specific to WBX right now.

    void initControlGPIO();

    bool getTXEna();
    bool getTXRelayOn(); 
    void locSetTXEna(bool val);

    void setTXFrontEndEnable(bool val); 
    
    static const unsigned int TX_RELAY_CTL; 
    static const unsigned int TX_RELAY_MON; 
    
    uhd::tune_result_t last_rx_tune_result; 
    uhd::tune_result_t last_tx_tune_result; 
    uhd::tune_result_t saved_rx_tune_result; 
 
    double first_gettime; 
 
    // gain settings
    double rx_rf_gain; 
    double tx_rf_gain; 
 
    uhd::gain_range_t rx_rf_gain_range; 
    uhd::gain_range_t tx_rf_gain_range; 
 
    uhd::freq_range_t rx_rf_freq_range; 
    uhd::freq_range_t tx_rf_freq_range; 
 
    // state of the box
    bool tx_on; 
 
    double last_rx_req_freq;  
    
    // we horse the TX tuning around when we switch to RX
    // to move the transmit birdie out of band.
    double tx_freq; 
    double tx_freq_rxmode_offset; 
    static const double rxmode_offset; 
 
    double tx_samp_rate; 
    std::string tx_ant;  
 
    std::string motherboard_name; 
    
    // enables verbose messages
    bool debug_mode; 
 
    // integer tuning mode is helped by a map of LO capabilities.

    void applyTargetFreqCorrection(double target_freq, 
                   double avoid_freq, 
                   uhd::tune_request_t * tune_req);
 

    void testIntNMode(bool force_int_N, bool force_frac_N);
 
    bool supports_IntN_Mode;  

    SoDa::USRPTRControl * tr_control;

    std::weak_ptr<USRPCtrl> self;
  };
}