USRPCtrl.hxx

Go to the documentation of this file.

/*
Copyright (c) 2012, 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.
*/


#ifndef USRPCTRL_HDR
#define USRPCTRL_HDR
#include "SoDaBase.hxx"
#include "MultiMBox.hxx"
#include "Command.hxx"
#include "Params.hxx"
#include "TRControl.hxx"
#include "PropTree.hxx"

#include <uhd/utils/thread_priority.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 <uhd/utils/msg.hpp>

namespace SoDa {


  class USRPCtrl : public SoDaThread {
  public:
    USRPCtrl(Params * params, CmdMBox * _cmd_stream);
    void run();

    uhd::usrp::multi_usrp::sptr getUSRP() { return usrp; }


    static void normal_message_handler(uhd::msg::type_t type, const std::string & msg);

    static SoDa::USRPCtrl * singleton_ctrl_obj;
    
  private:
    Params * params;

    bool is_B2xx;
    bool is_B210; 

    void execCommand(Command * cmd);
    void execGetCommand(Command * cmd); 
    void execSetCommand(Command * cmd); 
    void execRepCommand(Command * cmd); 

    double getTime();

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

    void reportAntennas(); 

    void reportModes(); 

    void reportAFFilters(); 

    void setAntenna(const std::string & ant, char sel); 

    void set1stLOFreq(double freq, char sel, bool set_if_freq = false);

    
    CmdMBox * cmd_stream; 
    unsigned int subid;   

    // USRP stuff.
    uhd::usrp::multi_usrp::sptr usrp; 
    uhd::usrp::dboard_iface::sptr dboard;  
    // need this for TX/RX enable.
    SoDa::PropTree * tx_fe_subtree; 
    // need this for TX/RX enable.
    SoDa::PropTree * 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 setTXEna(bool val);

    void setTXFrontEndEnable(bool val); 

    void setTransverterLOFreqPower(double freq, double power);
    void enableTransverterLO();
    void disableTransverterLO();
    
    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; 

    // transverter local oscillator support.
    bool tvrt_lo_capable; 
    bool tvrt_lo_mode; 
    double tvrt_lo_gain; 
    double tvrt_lo_freq; 
    double tvrt_lo_fe_freq; 
    
    // 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::TRControl * tr_control; 
  };
}


#endif