radio.cpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS control library
 *
 *  Copyright (C) 2023, 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
 */
 
#include "settings.hpp"
#include <etl/binary.h>
#include <etl/vector.h>
#include <satnogs-comms-lib/board.hpp>
#include <satnogs-comms-lib/bsp/chrono.hpp>
#include <satnogs-comms-lib/power.hpp>
#include <satnogs-comms-lib/radio.hpp>
 
namespace satnogs::comms::lib
{
 
static radio::rx_msg rx_msg;
static uint8_t       tx_bb09_pdu[AT86RF215_MAX_PDU];
static uint8_t       tx_bb24_pdu[AT86RF215_MAX_PDU];

static constexpr std::array<float, 8> fsk_mod_idxs = {
    0.375f, 0.5f, 0.75f, 1.0f, 1.25f, 1.5f, 1.75f, 2.0f};

static constexpr std::array<float, 4> fsk_bt = {0.5f, 1.0f, 1.5f, 2.0f};
 
/* Re-implementation of the AT86RF215 weak functions */
extern "C" {
int
at86rf215_set_rstn(struct at86rf215 *h, uint8_t enable)
{
  if (h->rst_gpio_dev) {
    bsp::gpio *rst_gpio_dev = static_cast<bsp::gpio *>(h->rst_gpio_dev);
    rst_gpio_dev->set(enable);
  }
  return AT86RF215_OK;
}
 
int
at86rf215_set_seln(struct at86rf215 *h, uint8_t enable)
{
  if (h->cs_gpio_dev) {
    bsp::gpio *cs_gpio_dev = static_cast<bsp::gpio *>(h->cs_gpio_dev);
    /*
     * NOTE: AT86RF215 uses physical pin level logic for the CS
     */
    cs_gpio_dev->set_raw(enable);
  }
  return AT86RF215_OK;
}
 
void
at86rf215_delay_us(struct at86rf215 *h, uint32_t us)
{
  bsp::chrono *chrono_dev = static_cast<bsp::chrono *>(h->user_dev0);
  chrono_dev->delay_us(us);
}
 
size_t
at86rf215_get_time_ms(struct at86rf215 *h)
{
  bsp::chrono *chrono_dev = static_cast<bsp::chrono *>(h->user_dev0);
  return chrono_dev->time_ms();
}
 
int
at86rf215_spi_read(struct at86rf215 *h, uint8_t *out, const uint8_t *in,
                   size_t tx_len, size_t rx_len)
{
  bsp::spi *spi_dev = static_cast<bsp::spi *>(h->spi_dev);
  spi_dev->read(out, in, tx_len, rx_len);
 
  return AT86RF215_OK;
}
 
int
at86rf215_spi_write(struct at86rf215 *h, const uint8_t *in, size_t len)
{
  bsp::spi *spi_dev = static_cast<bsp::spi *>(h->spi_dev);
  spi_dev->write(in, len);
  return AT86RF215_OK;
}
 
int
at86rf215_irq_user_callback(struct at86rf215 *h, uint8_t rf09_irqs,
                            uint8_t rf24_irqs, uint8_t bbc0_irqs,
                            uint8_t bbc1_irqs)
{
  radio *r = reinterpret_cast<radio *>(h->user_dev1);
  /* Check if a frame has been received */
  if (bbc0_irqs & bit<uint8_t, 1>()) {
    at86rf215_rx_frame(h, AT86RF215_RF09, rx_msg.pdu,
                       r->rx_len(radio::interface::UHF));
    rx_msg.info.len   = r->rx_len(radio::interface::UHF);
    rx_msg.info.iface = radio::interface::UHF;
    /*
     * Get the RSSI of the received frame. According to the datasheet this
     * should be the EDV register
     */
    int ret = at86rf215_get_edv(h, AT86RF215_RF09, &rx_msg.info.rssi);
    if (ret) {
      rx_msg.info.rssi = std::nanf("nan");
    }
 
    ret = r->m_rxq.put_isr(rx_msg);
    if (ret) {
      /* FIFO is full probably */
      r->m_rx_drop.call_if(radio::interface::UHF);
    }
 
    /* After the RXFE the AT86 does not enter RX mode */
    at86rf215_rx(h, AT86RF215_RF09, 1000);
  }
 
  /* Check if a frame has been received */
  if (bbc1_irqs & bit<uint8_t, 1>()) {
    at86rf215_rx_frame(h, AT86RF215_RF24, rx_msg.pdu,
                       r->rx_len(radio::interface::SBAND));
    rx_msg.info.len   = r->rx_len(radio::interface::SBAND);
    rx_msg.info.iface = radio::interface::SBAND;
    /*
     * Get the RSSI of the received frame. According to the datasheet this
     * should be the EDV register
     */
    int ret = at86rf215_get_edv(h, AT86RF215_RF24, &rx_msg.info.rssi);
    if (ret) {
      rx_msg.info.rssi = std::nanf("nan");
    }
 
    ret = r->m_rxq.put_isr(rx_msg);
    if (ret) {
      /* FIFO is full probably */
      r->m_rx_drop.call_if(radio::interface::SBAND);
    }
 
    /* After the RXFE the AT86 does not enter RX mode */
    at86rf215_rx(h, AT86RF215_RF24, 1000);
  }
  return AT86RF215_OK;
}
}

static at86rf215_radio_t
iface_to_at86_radio(radio::interface iface)
{
  switch (iface) {
  case radio::interface::UHF:
    return AT86RF215_RF09;
  case radio::interface::SBAND:
    return AT86RF215_RF24;
  default:
    throw inval_arg_exception(__FILE__, __LINE__);
  }
}

radio::radio(const params &p, const io_conf &cnf, power &pwr,
             bsp::imsgq<rx_msg> &rx_msgq)
    : m_frame_len{p.uhf_len, p.sband_len},
      m_spi(cnf.spi_ctrl),
      m_nrst(cnf.nreset),
      m_en_ext_clk(cnf.en_ext_clk),
      m_tx_mixer_params(p.tx_mixer_params),
      m_rx_mixer_params(p.rx_mixer_params),
      m_iface_enabled{false, false},
      m_rffe09(p.rffe09_params, cnf.rffe09_io, pwr),
      m_rffe24(p.rffe24_params, cnf.rffe24_io, pwr),
      m_chrono(cnf.chrono),
      m_pwr(pwr),
      m_rxq(rx_msgq),
      m_req_clk_src(p.clk),
      m_clk_src(clk_src::INTERNAL)
{
  bsp_setup();
  enable(false);
}

int
radio::trx_irq_handler()
{
  auto &r = board::get_instance().radio();
  return at86rf215_irq_callback(&r.m_at86);
}

void
radio::enable(bool yes)
{
  if (yes) {
    m_pwr.enable(power::subsys::RF_5V, true);
    at86rf215_enable(true);
  } else {
    /*
     * Disabling the whole chain is critical. Set explicitly the RF front-ends
     * as disabled and disable the corresponding power supplies
     */
    enable_uhf(false);
    enable_sband(false);
    m_pwr.enable(power::subsys::RF_5V, false);
  }
}
 
void
radio::enable_uhf(bool yes)
{
  /*
   * If the main radio is disabled and a disable request for the interface is
   * requested we cannot do much..
   */
  if (enabled() == false && yes == false) {
    m_rffe09.enable(false);
    m_iface_enabled[static_cast<uint8_t>(interface::UHF)] = false;
    return;
  }
 
  try {
    int ret = 0;
    if (yes) {
      ret = at86rf215_set_cmd(&m_at86, AT86RF215_CMD_RF_TXPREP, AT86RF215_RF09);
    } else {
      ret = at86rf215_set_trxoff(&m_at86, AT86RF215_RF09, 20);
    }
    ret += at86rf215_radio_irq_clear(&m_at86, AT86RF215_RF09);
    if (ret) {
      throw radio_exception(__FILE__, __LINE__);
    }
    m_rffe09.enable(yes);
    m_iface_enabled[static_cast<uint8_t>(interface::UHF)] = yes;
  } catch (...) {
    /* In case of error the interface is considered disabled */
    m_rffe09.enable(false);
    m_iface_enabled[static_cast<uint8_t>(interface::UHF)] = false;
    std::rethrow_exception(std::current_exception());
  }
}
 
void
radio::enable_sband(bool yes)
{
  /*
   * If the main radio is disabled and a disable request for the interface is
   * requested we cannot do much..
   */
  if (enabled() == false && yes == false) {
    m_rffe24.enable(false);
    m_iface_enabled[static_cast<uint8_t>(interface::SBAND)] = false;
    return;
  }
 
  try {
    int ret = 0;
    if (yes) {
      ret = at86rf215_set_cmd(&m_at86, AT86RF215_CMD_RF_TXPREP, AT86RF215_RF24);
    } else {
      ret = at86rf215_set_trxoff(&m_at86, AT86RF215_RF24, 20);
    }
    ret += at86rf215_radio_irq_clear(&m_at86, AT86RF215_RF24);
    if (ret) {
      throw radio_exception(__FILE__, __LINE__);
    }
    m_rffe24.enable(yes);
    m_iface_enabled[static_cast<uint8_t>(interface::SBAND)] = yes;
  } catch (...) {
    /* In case of error the interface is considered disabled */
    m_rffe24.enable(false);
    m_iface_enabled[static_cast<uint8_t>(interface::SBAND)] = false;
    std::rethrow_exception(std::current_exception());
  }
}

void
radio::enable(interface iface, bool yes)
{
  /* Enable the radio if it is not already enabled */
  if (yes && enabled() == false) {
    enable();
  }
 
  switch (iface) {
  case interface::UHF:
    enable_uhf(yes);
    break;
  case interface::SBAND:
    enable_sband(yes);
    break;
  default:
    throw inval_arg_exception(__FILE__, __LINE__);
  }
}

bool
radio::enabled() const
{
  return m_pwr.enabled(power::subsys::RF_5V) &&
         at86rf215_conn_check(&m_at86) == AT86RF215_OK;
}

void
radio::stop(interface iface, size_t timeout_ms)
{
  const at86rf215_radio_t r = iface_to_at86_radio(iface);
 
  switch (iface) {
  case interface::UHF:
    return m_rffe09.enable(false);
    break;
  case interface::SBAND:
    return m_rffe24.enable(false);
    break;
  default:
    throw inval_arg_exception(__FILE__, __LINE__);
  }
 
  /* [Errata reference 4840] Transition to TRXOFF may fail */
  at86rf215_set_trxoff(&m_at86, r, 20);
}

bool
radio::enabled(interface iface) const
{
  return enabled() && m_iface_enabled[static_cast<uint8_t>(iface)];
}

rf_frontend::dir
radio::direction(interface iface) const
{
  switch (iface) {
  case interface::UHF:
    return m_rffe09.direction();
    break;
  case interface::SBAND:
    return m_rffe24.direction();
    break;
  default:
    throw inval_arg_exception(__FILE__, __LINE__);
  }
}

void
radio::set_frequency(interface iface, rf_frontend::dir d, uint32_t freq)
{
  int ret = 0;
  switch (iface) {
  case interface::UHF: {
    if (m_rffe09.frequency_valid(d, freq) == false) {
      throw unsupported_freq_exception(__FILE__, __LINE__);
    }
 
    m_rffe09.set_direction(d);
    struct at86rf215_radio_conf cnf = {.cm  = AT86RF215_CM_FINE_RES_04,
                                       .lbw = AT86RF215_PLL_LBW_DEFAULT};
    ret = at86rf215_radio_conf(&m_at86, AT86RF215_RF09, &cnf);
    if (ret) {
      throw radio_exception(__FILE__, __LINE__);
    }
 
    ret = at86rf215_set_freq(&m_at86, AT86RF215_RF09, freq);
    if (ret) {
      throw radio_exception(__FILE__, __LINE__);
    }
  } break;
  case interface::SBAND: {
    if (m_rffe24.frequency_valid(d, freq) == false) {
      throw unsupported_freq_exception(__FILE__, __LINE__);
    }
 
    uint64_t lo = lo_freq(freq, d);
    m_rffe24.set_direction(d, lo);
    struct at86rf215_radio_conf cnf = {.cm  = AT86RF215_CM_FINE_RES_24,
                                       .lbw = AT86RF215_PLL_LBW_DEFAULT};
 
    ret = at86rf215_radio_conf(&m_at86, AT86RF215_RF24, &cnf);
    if (ret) {
      throw radio_exception(__FILE__, __LINE__);
    }
 
    ret = at86rf215_set_freq(&m_at86, AT86RF215_RF24, if_freq(freq, d));
    if (ret) {
      throw radio_exception(__FILE__, __LINE__);
    }
  } break;
  }
}

uint32_t
radio::frequency(interface iface, rf_frontend::dir d) const
{
  // TODO
  return 0.0;
}

void
radio::set_tx_gain(interface iface, float gain)
{
  const at86rf215_radio_t r = iface_to_at86_radio(iface);
  gain                      = etl::clamp(gain, 0.0f, 31.0f);
  at86rf215_set_pac(&m_at86, r, AT86RF215_PACUR_NO_RED, std::round(gain));
}

void
radio::set_rx_gain(interface iface, const rf_frontend::rx_gain_params &gain)
{
  const at86rf215_radio_t r = iface_to_at86_radio(iface);
 
  at86rf215_agc_conf agc_cnf = {.enable = 0,
                                .freeze = 0,
                                .reset  = 0,
                                .avgs   = AT86RF215_AVGS_8,
                                .input  = 0,
                                .gcw    = 23,
                                .tgt    = AT86RF215_TGT_M21};
 
  /* Manage gain settings for the AT86RF215 */
  if (gain.gain1_mode == rf_frontend::gain_mode::AUTO) {
    agc_cnf        = gain.gain1.agc;
    agc_cnf.enable = 1;
    agc_cnf.freeze = 0;
  } else {
    agc_cnf.enable = 0;
    agc_cnf.gcw =
        etl::clamp<uint8_t>(std::lroundf(gain.gain1.gain / 3.0f), 0U, 23U);
  }
  int ret = at86rf215_set_agc(&m_at86, r, &agc_cnf);
  if (ret) {
    throw radio_exception(__FILE__, __LINE__);
  }
 
  /* Now set the gain for the RF frontend */
  switch (iface) {
  case interface::UHF:
    m_rffe09.set_rx_gain(gain);
    break;
  case interface::SBAND:
    m_rffe24.set_rx_gain(gain);
    break;
  default:
    throw radio_exception(__FILE__, __LINE__);
  }
}

static bool
freq_in_range(const radio::mixer_param &p, uint32_t x)
{
  return x >= p.freq.first && x <= p.freq.second;
}

uint64_t
radio::lo_freq(uint32_t rf_freq, rf_frontend::dir d) const
{
  switch (d) {
  case rf_frontend::dir::RX: {
 
    for (const auto &i : m_rx_mixer_params) {
      if (freq_in_range(i, rf_freq)) {
        return i.lo;
      }
    }
    if (rf_freq < m_rx_mixer_params[0].freq.first) {
      return m_rx_mixer_params[0].lo;
    }
    return m_rx_mixer_params[1].lo;
  }
  case rf_frontend::dir::TX: {
    for (const auto &i : m_tx_mixer_params) {
      if (freq_in_range(i, rf_freq)) {
        return i.lo;
      }
    }
    if (rf_freq < m_tx_mixer_params[0].freq.first) {
      return m_tx_mixer_params[0].lo;
    }
    return m_tx_mixer_params[1].lo;
  }
  default:
    throw radio_exception(__FILE__, __LINE__);
  }
}

uint32_t
radio::if_freq(uint32_t rf_freq, rf_frontend::dir d) const
{
  uint64_t res = rf_freq + lo_freq(rf_freq, d);
  if (res > 0xFFFFFFFF) {
    throw radio_exception(__FILE__, __LINE__);
  }
  return res;
}

static std::pair<at86rf215_fsk_midx_t, at86rf215_fsk_midxs_t>
tune_fsk_mod_idx(float mod_idx)
{
  float   diff = std::fabs(mod_idx - fsk_mod_idxs[0] * 7.0f / 8.0f);
  uint8_t mod  = 0;
  uint8_t s    = 0;
  for (uint8_t i = 0; i < fsk_mod_idxs.size(); i++) {
    float scaling = 7.0f / 8.0f;
    for (uint8_t j = 0; j < 4; j++) {
      const auto x = std::fabs(mod_idx - fsk_mod_idxs[i] * scaling);
      if (x < diff) {
        mod  = i;
        s    = j;
        diff = x;
      }
      scaling += 1.0f / 8.0f;
    }
  }
  return {static_cast<at86rf215_fsk_midx_t>(mod),
          static_cast<at86rf215_fsk_midxs_t>(s)};
}

static at86rf215_fsk_bt_t
tune_fsk_bt(float bt)
{
  float   diff = std::fabs(bt - fsk_bt[0]);
  uint8_t idx  = 0;
  for (uint8_t i = 1; i < fsk_bt.size(); i++) {
    const float x = std::fabs(bt - fsk_bt[i]);
    if (x < diff) {
      diff = x;
      idx  = i;
    }
  }
  return static_cast<at86rf215_fsk_bt_t>(idx);
}

void
radio::set_tx_conf(interface iface, const tx_conf &conf)
{
  const at86rf215_radio_t r = iface_to_at86_radio(iface);
 
  /* For best performance the transceiver should be at TRXOFF state */
  at86rf215_set_trxoff(&m_at86, r, 20);
  set_frequency(iface, rf_frontend::dir::TX, conf.freq);
  set_tx_gain(iface, conf.gain);
  at86rf215_set_cmd(&m_at86, AT86RF215_CMD_RF_TXPREP, r);
 
  /* At this point the PLL should be locked! */
  m_chrono.delay_us(pll_ch_sw_delay_us);
  bool locked = get_pll_ls(iface);
  if (!locked) {
    throw pll_ls_exception(__FILE__, __LINE__);
  }
 
  int ret = at86rf215_set_radio_irq_mask(&m_at86, r, TX_RF_IRQM);
  ret += at86rf215_set_bbc_irq_mask(&m_at86, r, TX_BB_IRQM);
  if (ret) {
    throw radio_exception(__FILE__, __LINE__);
  }
 
  /* Fetch the best settings that match the user defined modulation index */
  auto mod_idx = tune_fsk_mod_idx(conf.fsk.mod_idx);
 
  /* FSK-2 50kHz */
  struct at86rf215_bb_conf at86_bb;
  at86_bb.ctx                    = 0;
  at86_bb.fcsfe                  = 0;
  at86_bb.txafcs                 = 1;
  at86_bb.fcst                   = AT86RF215_FCS_16;
  at86_bb.pt                     = AT86RF215_BB_MRFSK;
  at86_bb.fsk.mord               = AT86RF215_2FSK;
  at86_bb.fsk.midx               = mod_idx.first;
  at86_bb.fsk.midxs              = mod_idx.second;
  at86_bb.fsk.bt                 = tune_fsk_bt(conf.fsk.excess_bw);
  at86_bb.fsk.srate              = conf.fsk.rate;
  at86_bb.fsk.fi                 = 0;
  at86_bb.fsk.rxo                = AT86RF215_FSK_RXO_DISABLED;
  at86_bb.fsk.pdtm               = 0;
  at86_bb.fsk.rxpto              = 1;
  at86_bb.fsk.mse                = 0;
  at86_bb.fsk.pri                = 0;
  at86_bb.fsk.fecs               = AT86RF215_FSK_FEC_RSC;
  at86_bb.fsk.fecie              = 0;
  at86_bb.fsk.sfd_threshold      = 15;
  at86_bb.fsk.preamble_threshold = 8;
  at86_bb.fsk.sfdq               = 1;
  at86_bb.fsk.sfd32              = 1;
  at86_bb.fsk.rawrbit            = 1;
  at86_bb.fsk.csfd1              = AT86RF215_SFD_UNCODED_RAW;
  at86_bb.fsk.csfd0              = AT86RF215_SFD_UNCODED_RAW;
  at86_bb.fsk.preamble_length    = conf.preamble_len;
  /* SFD operates in a LSB order*/
  at86_bb.fsk.sfd0 = static_cast<uint16_t>(etl::reverse_bits(conf.sync));
  at86_bb.fsk.sfd1 = static_cast<uint16_t>(etl::reverse_bits(conf.sync) >> 16);
  at86_bb.fsk.sfd  = 0;
  at86_bb.fsk.dw   = 0;
  at86_bb.fsk.preemphasis = 0;
  at86_bb.fsk.dm          = 1;
 
  ret = at86rf215_bb_conf(&m_at86, r, &at86_bb);
  ret += at86rf215_set_mode(&m_at86, AT86RF215_RF_MODE_BBRF);
  ret += at86rf215_set_cmd(&m_at86, AT86RF215_CMD_RF_TXPREP, r);
  ret += at86rf215_radio_irq_clear(&m_at86, r);
  ret += at86rf215_bb_enable(&m_at86, r, 1);
  if (ret) {
    throw radio_exception(__FILE__, __LINE__);
  }
}

void
radio::tx(interface iface, const uint8_t *b)
{
 
  const at86rf215_radio_t r = iface_to_at86_radio(iface);
  uint8_t *tx_pdu = iface == interface::UHF ? tx_bb09_pdu : tx_bb24_pdu;
 
  memcpy(tx_pdu, b, tx_len(iface));
 
  int ret = at86rf215_tx_frame(&m_at86, r, tx_pdu, tx_len(iface), 2000);
  if (ret) {
    if (ret == -AT86RF215_TIMEOUT) {
      throw timeout_exception(__FILE__, __LINE__);
    }
    throw radio_exception(__FILE__, __LINE__, ret);
  }
}

void
radio::rx_async(interface iface, const rx_conf &conf)
{
  const at86rf215_radio_t r = iface_to_at86_radio(iface);
  enable(iface);
  /* For best performance the transceiver should be at TRXOFF state */
  at86rf215_set_trxoff(&m_at86, r, 20);
  set_frequency(iface, rf_frontend::dir::RX, conf.freq);
  at86rf215_set_cmd(&m_at86, AT86RF215_CMD_RF_TXPREP, r);
 
  /* At this point the PLL should be locked! */
  m_chrono.delay_us(pll_ch_sw_delay_us);
  bool locked = get_pll_ls(iface);
  if (!locked) {
    throw pll_ls_exception(__FILE__, __LINE__);
  }
 
  int ret = at86rf215_set_radio_irq_mask(&m_at86, r, RX_RF_IRQM);
  ret += at86rf215_set_bbc_irq_mask(&m_at86, r, RX_BB_IRQM);
  if (ret) {
    throw radio_exception(__FILE__, __LINE__);
  }
 
  set_rx_gain(iface, conf.gain);
 
  /* Apply the hardware filter path */
  if (iface == interface::UHF) {
    uhf().set_filter(conf.filter);
  } else {
    sband().set_filter(conf.filter);
  }
 
  /* Fetch the best settings that match the user defined modulation index */
  auto mod_idx = tune_fsk_mod_idx(conf.fsk.mod_idx);
 
  /* FSK-2 50kHz */
  struct at86rf215_bb_conf at86_bb;
  at86_bb.ctx                    = 0;
  at86_bb.fcsfe                  = 0;
  at86_bb.txafcs                 = 1;
  at86_bb.fcst                   = AT86RF215_FCS_16;
  at86_bb.pt                     = AT86RF215_BB_MRFSK;
  at86_bb.fsk.mord               = AT86RF215_2FSK;
  at86_bb.fsk.midx               = mod_idx.first;
  at86_bb.fsk.midxs              = mod_idx.second;
  at86_bb.fsk.bt                 = tune_fsk_bt(conf.fsk.excess_bw);
  at86_bb.fsk.srate              = conf.fsk.rate;
  at86_bb.fsk.fi                 = 0;
  at86_bb.fsk.rxo                = AT86RF215_FSK_RXO_DISABLED;
  at86_bb.fsk.pdtm               = 0;
  at86_bb.fsk.rxpto              = 1;
  at86_bb.fsk.mse                = 0;
  at86_bb.fsk.pri                = 0;
  at86_bb.fsk.fecs               = AT86RF215_FSK_FEC_RSC;
  at86_bb.fsk.fecie              = 0;
  at86_bb.fsk.sfd_threshold      = 12;
  at86_bb.fsk.preamble_threshold = 4;
  at86_bb.fsk.sfdq               = 0;
  at86_bb.fsk.sfd32              = 1;
  at86_bb.fsk.rawrbit            = 1; // Most of the encoders transmit MSB first
  at86_bb.fsk.csfd1              = AT86RF215_SFD_UNCODED_RAW;
  at86_bb.fsk.csfd0              = AT86RF215_SFD_UNCODED_RAW;
  at86_bb.fsk.preamble_length    = conf.preamble_len;
  /* SFD operates in a LSB order*/
  at86_bb.fsk.sfd0 = static_cast<uint16_t>(etl::reverse_bits(conf.sync));
  at86_bb.fsk.sfd1 = static_cast<uint16_t>(etl::reverse_bits(conf.sync) >> 16);
  at86_bb.fsk.sfd  = 0;
  at86_bb.fsk.dw   = 0;
  at86_bb.fsk.preemphasis = 0;
  at86_bb.fsk.dm          = 1;
 
  /* Apply the fixed size frame length */
  at86_bb.fsk.fskrrxf = rx_len(iface);
 
  ret = at86rf215_bb_conf(&m_at86, r, &at86_bb);
  ret += at86rf215_set_mode(&m_at86, AT86RF215_RF_MODE_BBRF);
  ret += at86rf215_radio_irq_clear(&m_at86, r);
  ret += at86rf215_bb_enable(&m_at86, r, 1);
  ret += at86rf215_rx(&m_at86, r, 1000);
  if (ret) {
    throw radio_exception(__FILE__, __LINE__);
  }
}

bool
radio::mixer_lock()
{
  return m_rffe24.mixer_lock();
}

rf_frontend09 &
radio::uhf()
{
  return m_rffe09;
}

rf_frontend24 &
radio::sband()
{
  return m_rffe24;
}

int
radio::recv_msg(rx_msg &msg, size_t timeout_ms)
{
  return m_rxq.get(&msg, timeout_ms);
}

uint32_t
radio::tx_len(interface iface) const
{
  return m_frame_len[iface_idx(iface)].tx;
}

uint32_t
radio::rx_len(interface iface) const
{
  return m_frame_len[iface_idx(iface)].rx;
}

void
radio::bsp_setup()
{
  m_at86.spi_dev      = &m_spi;
  m_at86.cs_gpio_dev  = &m_spi.cs();
  m_at86.rst_gpio_dev = &m_nrst;
  /* We use the user0 field for the chrono related stuff */
  m_at86.user_dev0 = &m_chrono;
  /*
   * user1 has the class itself for handling the user defined IRQ handler of
   * the AT86RF215 driver
   */
  m_at86.user_dev1 = this;
}

void
radio::at86rf215_enable(bool enable)
{
  /* In case the user needs to disable the IC, just de-assert the RSTN pin */
  if (enable == false) {
    at86rf215_set_rstn(&m_at86, 0);
    return;
  }
 
  m_at86.clk_drv      = AT86RF215_RF_DRVCLKO4;
  m_at86.clko_os      = AT86RF215_RF_CLKO_26_MHZ;
  m_at86.xo_trim      = 0;
  m_at86.xo_fs        = 0;
  m_at86.irqp         = 0;
  m_at86.irqmm        = 0;
  m_at86.pad_drv      = AT86RF215_RF_DRV8;
  m_at86.rf_femode_09 = AT86RF215_RF_FEMODE2;
  m_at86.rf_femode_24 = AT86RF215_RF_FEMODE2;
 
  /*
   * If the clock reference is not present, the at86rf215_init() fails.
   * So this is a good time to set the clock source. In case of failure
   * the radio fallback to the internal one
   */
  int ret = 0;
  if (m_req_clk_src == clk_src::EXTERNAL) {
    m_en_ext_clk.set(m_req_clk_src == clk_src::EXTERNAL);
    m_chrono.delay_us(clk_rfsw_delay_us);
    ret = at86rf215_init(&m_at86);
    /* In case of failure, fallback to the internal clock reference*/
    if (ret) {
      m_en_ext_clk.set(false);
      m_chrono.delay_us(clk_rfsw_delay_us);
      ret       = at86rf215_init(&m_at86);
      m_clk_src = clk_src::INTERNAL;
    } else {
      m_clk_src = clk_src::EXTERNAL;
    }
  } else {
    /* Explicitly set it to internal in case any abnormal previous state */
    m_en_ext_clk.set(false);
    m_chrono.delay_us(clk_rfsw_delay_us);
    m_clk_src = clk_src::INTERNAL;
    ret       = at86rf215_init(&m_at86);
  }
 
  /*
   * init() makes several checks so it will be good to raise an exception
   * specifically for it
   */
  if (ret) {
    throw radio_exception(__FILE__, __LINE__);
  }
 
  at86rf215_set_trxoff(&m_at86, AT86RF215_RF09, 20);
  at86rf215_set_trxoff(&m_at86, AT86RF215_RF24, 20);
  at86rf215_irq_clear(&m_at86);
}

void
radio::set_clk_src(clk_src src)
{
  m_req_clk_src = src;
}

radio::clk_src
radio::get_clk_src() const
{
  return m_clk_src;
}

bool
radio::get_pll_ls(interface iface)
{
  at86rf215_pll_ls_t status = AT86RF215_PLL_UNLOCKED;
  switch (iface) {
  case interface::UHF: {
    at86rf215_get_pll_ls(&m_at86, &status, iface_to_at86_radio(interface::UHF));
    return status == AT86RF215_PLL_LOCKED;
  }
  case interface::SBAND: {
    at86rf215_get_pll_ls(&m_at86, &status,
                         iface_to_at86_radio(interface::SBAND));
    return status == AT86RF215_PLL_LOCKED;
  }
  default:
    return AT86RF215_PLL_UNLOCKED;
  }
}

void
radio::register_rx_drop_callback(etl::delegate<void(interface)> callback)
{
  m_rx_drop = callback;
}
 
uint32_t
radio::iface_idx(interface iface) const
{
  switch (iface) {
  case interface::UHF:
  case interface::SBAND:
    return static_cast<uint32_t>(iface);
  default:
    throw inval_arg_exception(__FILE__, __LINE__);
  }
}
 
} // namespace satnogs::comms::lib