radio.hpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS control library
 *
 *  Copyright (C) 2023-2024, Libre Space Foundation <http://libre.space>
 *
 *  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/>.
 *
 *  SPDX-License-Identifier: GNU General Public License v3.0 or later
 */
 
#pragma once
 
#include <at86rf215.h>
#include <etl/delegate.h>
#include <etl/vector.h>
#include <satnogs-comms-lib/bsp/chrono.hpp>
#include <satnogs-comms-lib/bsp/msgq.hpp>
#include <satnogs-comms-lib/bsp/spi.hpp>
#include <satnogs-comms-lib/rf_frontend09.hpp>
#include <satnogs-comms-lib/rf_frontend24.hpp>
#include <satnogs-comms-lib/temperature.hpp>
#include <satnogs-comms-lib/utils/utils.hpp>
#include <satnogs-comms-lib/version.hpp>
 
namespace satnogs::comms::lib
{

class pll_ls_exception : public exception
{
public:
  pll_ls_exception(string_type file_name, numeric_type line)
      : exception(exception::severity::MINOR, file_name, line,
                  error_msg{"PLL clock status unlocked", "pllerr", EPLL})
  {
  }
};

class radio_exception : public exception
{
public:
  radio_exception(string_type file_name, numeric_type line)
      : exception(exception::severity::MAJOR, file_name, line,
                  error_msg{"Radio error", "radioerr", ERADIO})
  {
  }
 
  radio_exception(string_type file_name, numeric_type line, int err)
      : exception(exception::severity::MAJOR, file_name, line,
                  error_msg{"Radio error", "radioerr", err})
  {
  }
};

class unsupported_freq_exception : public exception
{
public:
  unsupported_freq_exception(string_type file_name, numeric_type line)
      : exception(exception::severity::MAJOR, file_name, line,
                  error_msg{"Unsupported frequency error", "freqerr", EBADFREQ})
  {
  }
};
 
/*
 * This is a weak function of the AT86RF215 driver allowing user defined
 * processing of the IRQs. We need to forward declare it here in order
 * to define it as friend of the radio class.
 * With this trick, this callback can access the private fields of the radio
 * class. This eliminate the need for the radio class to expose at the public
 * API, dangerous/unnecessary methods
 */
extern "C" int
at86rf215_irq_user_callback(struct at86rf215 *h, uint8_t rf09_irqs,
                            uint8_t rf24_irqs, uint8_t bbc0_irqs,
                            uint8_t bbc1_irqs);

class radio
{
public:
  static const uint16_t UHF_AGC_VOUT_DAC_CH = 2;

  static const uint16_t SBAND_AGC_VOUT_DAC_CH = 1;

  class mixer_param
  {
  public:
    std::pair<uint32_t, uint32_t> freq; 
    uint64_t
        lo; 
  };
 
  class frame_len
  {
  public:
    uint32_t tx;
    uint32_t rx;
  };

  enum class clk_src : bool
  {
    INTERNAL = 0, 
    EXTERNAL = 1  
  };

  enum class interface : uint8_t
  {
    UHF   = 0, 
    SBAND = 1  
  };

  enum class op_mode : uint8_t
  {
    BASEBAND, 
    IQ        
  };

  enum class modulation : uint8_t
  {
    FSK,  
    FSK4, 
    QPSK  
  };

  class io_conf
  {
  public:
    bsp::spi  &spi_ctrl; 
    bsp::gpio &nreset;   
    bsp::gpio
        &en_ext_clk; 
    bsp::chrono &chrono; 
    rf_frontend09::io_conf
        &rffe09_io; 
    rf_frontend24::io_conf
        &rffe24_io; 
  };

  class params
  {
  public:
    rf_frontend::params rffe09_params; 
    rf_frontend::params rffe24_params; 
    frame_len           uhf_len;       
    frame_len           sband_len;     
    std::array<mixer_param, 2>
        tx_mixer_params; 
    std::array<mixer_param, 2>
            rx_mixer_params; 
    clk_src clk;             
  };

  class fsk_conf
  {
  public:
    at86rf215_fsk_srate_t rate; 
    float mod_idx; 
    float excess_bw; 
  };

  class rx_info
  {
  public:
    float rssi; 
    float     edv;   
    uint32_t  len;   
    interface iface; 
  };

  class rx_msg
  {
  public:
    uint8_t pdu[AT86RF215_MAX_PDU]; 
    rx_info info;                   
  };

  class rx_conf
  {
  public:
    uint32_t freq;                      
    uint8_t  preamble_len;              
    uint32_t sync;                      
    fsk_conf fsk;                       
    rf_frontend::rx_gain_params gain;   
    rf_frontend::filter         filter; 
  };
 
  class tx_conf
  {
  public:
    uint32_t freq;         
    uint8_t  preamble_len; 
    uint32_t sync;         
    fsk_conf fsk;          
    float    gain;         
  };
 
  radio(const params &p, const io_conf &cnf, power &pwr,
        bsp::imsgq<rx_msg> &rx_msgq);
 
  static int
  trx_irq_handler();
 
  void
  enable(bool yes = true);
 
  void
  enable(interface iface, bool yes = true);
 
  bool
  enabled() const;
 
  void
  stop(interface iface, size_t timeout_ms = 1000);
 
  bool
  enabled(interface iface) const;
 
  rf_frontend::dir
  direction(interface iface) const;
 
  void
  set_frequency(interface iface, rf_frontend::dir d, uint32_t freq);
 
  uint32_t
  frequency(interface iface, rf_frontend::dir d) const;
 
  void
  set_tx_gain(interface iface, float gain);
 
  void
  set_tx_conf(interface iface, const tx_conf &conf);
 
  void
  tx(interface iface, const uint8_t *b);
 
  void
  rx_async(interface iface, const rx_conf &conf);
 
  bool
  mixer_lock();
 
  clk_src
  get_clk_src() const;
 
  rf_frontend09 &
  uhf();
 
  rf_frontend24 &
  sband();
 
  int
  recv_msg(rx_msg &msg, size_t timeout_ms);
 
  uint32_t
  tx_len(interface iface) const;
 
  uint32_t
  rx_len(interface iface) const;
 
  void
  set_clk_src(clk_src src);
 
  bool
  get_pll_ls(interface iface);
 
  void
  register_rx_drop_callback(etl::delegate<void(interface)> callback);
 
private:
  /* None! */
  static constexpr uint8_t TX_RF_IRQM = 0x0;
  /* TXFE */
  static constexpr uint8_t TX_BB_IRQM = bit<uint8_t, 4>();
 
  /* None */
  static constexpr uint8_t RX_RF_IRQM = 0x0;
 
  /* RXFE */
  static constexpr uint8_t RX_BB_IRQM = bit<uint8_t, 1>();
 
  /* Clock source RF switch delay */
  static constexpr uint32_t clk_rfsw_delay_us = 50;
 
  /* Maximum delay for the PLL to lock after a channel switch request */
  static constexpr uint32_t pll_ch_sw_delay_us = 100;
 
  const frame_len                m_frame_len[2];
  bsp::spi                      &m_spi;
  bsp::gpio                     &m_nrst;
  bsp::gpio                     &m_en_ext_clk;
  std::array<mixer_param, 2>     m_tx_mixer_params;
  std::array<mixer_param, 2>     m_rx_mixer_params;
  mutable struct at86rf215       m_at86;
  bool                           m_iface_enabled[2];
  rf_frontend09                  m_rffe09;
  rf_frontend24                  m_rffe24;
  bsp::chrono                   &m_chrono;
  power                         &m_pwr;
  bsp::imsgq<rx_msg>            &m_rxq;
  clk_src                        m_req_clk_src; // Requested clock source
  clk_src                        m_clk_src;     // Actual clock source
  etl::delegate<void(interface)> m_rx_drop;
 
  void
  bsp_setup();
 
  void
  at86rf215_enable(bool enable = true);
 
  friend int
  at86rf215_irq_user_callback(struct at86rf215 *h, uint8_t rf09_irqs,
                              uint8_t rf24_irqs, uint8_t bbc0_irqs,
                              uint8_t bbc1_irqs);
 
  uint32_t
  iface_idx(interface iface) const;
 
  void
  set_rx_gain(interface iface, const rf_frontend::rx_gain_params &gain);
 
  uint64_t
  lo_freq(uint32_t rf_freq, rf_frontend::dir d) const;
 
  uint32_t
  if_freq(uint32_t rf_freq, rf_frontend::dir d) const;
 
  void
  enable_uhf(bool yes = true);
 
  void
  enable_sband(bool yes = true);
};

 
} // namespace satnogs::comms::lib