iface_ctrl.cpp

Go to the documentation of this file.

#include "iface_ctrl.hpp"
 
#include "io_wdg.hpp"
#include <dsp/ccsds.hpp>
#include <error_handler.hpp>
#include <etl/algorithm.h>
#include <etl/crc.h>
#include <logger.hpp>
#include <scoped_lock.hpp>
#include <settings.hpp>
#include <startup.hpp>
 
namespace sc  = satnogs::comms;
namespace scl = satnogs::comms::lib;
 
namespace satnogs::comms::utils
{
 
iface_ctrl::iface_ctrl(scl::radio::interface iface)
    : fsm(unique_message_router_id::get()), m_iface(iface), m_pending(false)
{
  k_work_init(&m_work, &iface_ctrl::timer_work_handler);
  k_timer_init(&m_timer, &iface_ctrl::timer_handler, nullptr);
  k_timer_user_data_set(&m_timer, this);
  k_mutex_init(&m_mtx);
  k_condvar_init(&m_cond_var);
 
  m_state_list[0] = &m_disabled_state;
  m_state_list[1] = &m_tx_state;
  m_state_list[2] = &m_rx_state;
  m_state_list[3] = &m_idle_state;
 
  set_states(m_state_list, 4);
  start();
}

void
iface_ctrl::enable()
{
  receive(rx_msg());
}
 
void
iface_ctrl::enable(bool yes)
{
  if (yes) {
    enable();
  } else {
    disable();
  }
}

void
iface_ctrl::disable()
{
  receive(disable_msg());
}

void
iface_ctrl::restart()
{
  disable();
  enable();
}

void
iface_ctrl::reset_stats()
{
  m_stats.reset();
}

const iface_ctrl::stats &
iface_ctrl::get_stats() const
{
  return m_stats;
}
 
void
iface_ctrl::tx(const msg_arbiter::msg &msg, bool more)
{
  /* Check if the TX inhibit is activated */
  auto &s     = settings::get_instance();
  bool  tx_en = m_iface == scl::radio::interface::UHF
                    ? s.get<settings::param::UHF_TX_EN>()
                    : s.get<settings::param::SBAND_TX_EN>();
  if (!tx_en) {
    throw tx_inhibit_exception(__FILE__, __LINE__);
  }
 
  wait_pending_operation();
  m_tx_msg  = msg;
  m_tx_wait = more;
  receive(tx_frame_msg());
}

iface_ctrl::state
iface_ctrl::get_state() const
{
  return static_cast<iface_ctrl::state>(get_state_id());
}
 
void
iface_ctrl::wait_pending_operation()
{
  scoped_lock lock(&m_mtx);
  while (m_pending) {
    k_condvar_wait(&m_cond_var, &m_mtx, K_FOREVER);
  }
}

void
iface_ctrl::frame_sent(bool success)
{
  if (success) {
    if (m_stats.tx_frames < std::numeric_limits<size_t>::max()) {
      m_stats.tx_frames++;
    }
  } else {
    if (m_stats.tx_frames_fail < std::numeric_limits<size_t>::max()) {
      m_stats.tx_frames_fail++;
    }
  }
}

void
iface_ctrl::tx_frame_dropped()
{
  if (m_stats.tx_frames_drop < std::numeric_limits<size_t>::max()) {
    m_stats.tx_frames_drop++;
  }
}

bool
iface_ctrl::duty_cycle_enabled()
{
  auto    &s        = settings::get_instance();
  uint32_t on_secs  = m_iface == scl::radio::interface::UHF
                          ? s.get<settings::param::UHF_RX_ON_SECS>()
                          : s.get<settings::param::SBAND_RX_ON_SECS>();
  uint32_t off_secs = m_iface == scl::radio::interface::UHF
                          ? s.get<settings::param::UHF_RX_OFF_SECS>()
                          : s.get<settings::param::SBAND_RX_OFF_SECS>();
  return on_secs > 0 && off_secs > 0;
}

void
iface_ctrl::frame_received(bool valid, float rssi)
{
  m_stats.last_rssi  = rssi;
  m_stats.last_rx_ts = k_uptime_get();
  if (valid) {
    /* In case of a valid frame reset the IO/GS watchdog */
    io_wdg::get_instance().reset();
    if (m_stats.rx_frames < std::numeric_limits<size_t>::max()) {
      m_stats.rx_frames++;
    }
    m_stats.last_valid_rssi  = rssi;
    m_stats.last_valid_rx_ts = k_uptime_get();
  } else {
    if (m_stats.rx_frames_inval < std::numeric_limits<size_t>::max()) {
      m_stats.rx_frames_inval++;
    }
  }
}

void
iface_ctrl::rx_frame_dropped()
{
  if (m_stats.rx_frames_drop < std::numeric_limits<size_t>::max()) {
    m_stats.rx_frames_drop++;
  }
}
 
void
iface_ctrl::timer_handler(k_timer *t)
{
  iface_ctrl *ctx = static_cast<iface_ctrl *>(k_timer_user_data_get(t));
  if (!ctx) {
    return;
  }
 
  if (k_work_is_pending(&ctx->m_work)) {
    return;
  }
  k_work_submit(&ctx->m_work);
}
 
void
iface_ctrl::timer_work_handler(k_work *item)
{
  auto ctx = CONTAINER_OF(item, iface_ctrl, m_work);
 
  scoped_lock lock(&ctx->m_mtx);
  while (ctx->m_pending) {
    k_condvar_wait(&ctx->m_cond_var, &ctx->m_mtx, K_FOREVER);
  }
 
  /* Waiting for the next TX timed out. Go again in RX */
  if (ctx->get_state() == iface_ctrl::state::TX) {
    ctx->receive(rx_msg());
  }
  /* Idle timer has expired, go again on the RX state */
  else if (ctx->get_state() == iface_ctrl::state::IDLE) {
    ctx->receive(rx_msg());
  } else if (ctx->get_state() == iface_ctrl::state::RX) {
    ctx->receive(idle_msg());
  }
}
 
/*****************************************************************************
 *****************************************************************************
 ************************** Disabled state handling **************************
 *****************************************************************************
 *****************************************************************************/
 
etl::fsm_state_id_t
iface_ctrl::disabled_state::on_enter_state()
{
  auto &ctx = get_fsm_context();
  auto &log = sc::logger::get_instance();
  log.log({sc::logger::target::RTT},
          ctx.m_iface == scl::radio::interface::UHF
              ? "iface_ctrl<UHF>: disabled iface. enter disabled state"
              : "iface_ctrl<S-Band>: disabled iface. enter disabled state");
  auto &radio = scl::board::get_instance().radio();
  k_timer_stop(&ctx.m_timer);
  radio.enable(ctx.m_iface, false);
  return No_State_Change;
}
 
etl::fsm_state_id_t
iface_ctrl::disabled_state::on_event(const rx_msg &msg)
{
  return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::RX);
}
 
etl::fsm_state_id_t
iface_ctrl::disabled_state::on_event(const tx_frame_msg &msg)
{
  auto &log = sc::logger::get_instance();
  auto &ctx = get_fsm_context();
  log.log({sc::logger::target::RTT},
          ctx.m_iface == scl::radio::interface::UHF
              ? "iface_ctrl<UHF>: disabled iface. Dropping TX msg"
              : "iface_ctrl<S-Band>: disabled iface. Dropping TX msg");
  ctx.tx_frame_dropped();
  return No_State_Change;
}
 
etl::fsm_state_id_t
iface_ctrl::disabled_state::on_event_unknown(const etl::imessage &msg)
{
  auto &ctx = get_fsm_context();
  auto &log = sc::logger::get_instance();
  log.log({sc::logger::target::RTT},
          ctx.m_iface == scl::radio::interface::UHF
              ? "iface_ctrl<UHF>: disabled state unknown msg"
              : "iface_ctrl<S-Band>: disabled state unknown msg");
  return No_State_Change;
}
 
/*****************************************************************************
 *****************************************************************************
 ***************************** TX state handling *****************************
 *****************************************************************************
 *****************************************************************************/
 
etl::fsm_state_id_t
iface_ctrl::tx_state::on_enter_state()
{
  auto &ctx = get_fsm_context();
  auto &log = sc::logger::get_instance();
  try {
    scoped_lock lock(&ctx.m_mtx);
    ctx.m_pending = true;
    log.log({sc::logger::target::RTT},
            ctx.m_iface == scl::radio::interface::UHF
                ? "iface_ctrl<UHF>: enter TX state"
                : "iface_ctrl<S-Band>: enter TX state");
    auto &radio = scl::board::get_instance().radio();
    auto &s     = settings::get_instance();
 
    /*
     * Force the interface to stop. This will close all the analog chain of the
     * AT86RF215. Note that if the radio in general is not enabled, this does
     * not make any sense.
     */
    if (radio.enabled()) {
      radio.stop(ctx.m_iface);
    }
    /*
     * If this is a transition from another state, apply the TX settings and
     * perform the TX of the frame
     */
    radio.enable(ctx.m_iface, true);
 
    /* Get the TX configuration */
    lib::radio::tx_conf cnf;
    s.get_tx_conf(ctx.m_iface, cnf);
    radio.set_tx_conf(ctx.m_iface, cnf);
 
    /* Do DSP and send it! */
    auto crc = etl::crc32_c(ctx.m_tx_msg.data, ctx.m_tx_msg.data +
                                                   radio.tx_len(ctx.m_iface) -
                                                   sizeof(uint32_t))
                   .value();
 
    ctx.m_tx_msg.data[radio.tx_len(ctx.m_iface) - 4] = crc >> 24;
    ctx.m_tx_msg.data[radio.tx_len(ctx.m_iface) - 3] = crc >> 16;
    ctx.m_tx_msg.data[radio.tx_len(ctx.m_iface) - 2] = crc >> 8;
    ctx.m_tx_msg.data[radio.tx_len(ctx.m_iface) - 1] = crc;
    dsp::ccsds::scrambler(ctx.m_tx_msg.data, radio.tx_len(ctx.m_iface));
 
    radio.tx(ctx.m_iface, ctx.m_tx_msg.data);
    ctx.frame_sent(true);
 
    /*
     * Fireup the timer that allows the interface to stay in TX mode for the
     * configured amount of time to increase throughput
     */
    if (ctx.m_tx_wait) {
      uint32_t wait_ms = ctx.m_iface == scl::radio::interface::UHF
                             ? s.get<settings::param::UHF_TX_WAIT_MS>()
                             : s.get<settings::param::SBAND_TX_WAIT_MS>();
      k_timer_start(&ctx.m_timer, K_MSEC(wait_ms), K_NO_WAIT);
 
      ctx.m_pending = false;
      k_condvar_broadcast(&ctx.m_cond_var);
      return No_State_Change;
    } else {
      ctx.m_pending = false;
      k_condvar_broadcast(&ctx.m_cond_var);
      return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::RX);
    }
  } catch (const scl::exception &e) {
    ctx.frame_sent(false);
    log.log({sc::logger::target::RTT},
            ctx.m_iface == scl::radio::interface::UHF
                ? "iface_ctrl<UHF>: Exception occurred"
                : "iface_ctrl<S-Band>: Exception occurred");
    auto &err = error_handler::get_instance();
    err.handle(e);
    ctx.m_pending = false;
    k_condvar_broadcast(&ctx.m_cond_var);
    return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::IDLE);
  }
}
 
void
iface_ctrl::tx_state::on_exit_state()
{
  auto &ctx = get_fsm_context();
  k_timer_stop(&ctx.m_timer);
  ctx.wait_pending_operation();
}
 
etl::fsm_state_id_t
iface_ctrl::tx_state::on_event(const disable_msg &msg)
{
  auto &ctx = get_fsm_context();
  /*
   * NOTE: Disable first the timer to avoid accidental fireup while waiting for
   * the operation to finish
   */
  k_timer_stop(&ctx.m_timer);
  /* Let the final frame finish  */
  ctx.wait_pending_operation();
  return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::DISABLED);
}
 
etl::fsm_state_id_t
iface_ctrl::tx_state::on_event(const tx_frame_msg &msg)
{
  auto &ctx = get_fsm_context();
  auto &log = sc::logger::get_instance();
  auto &s   = settings::get_instance();
  try {
    /* Stop the timer we do not want to expire in the middle of a TX */
    k_timer_stop(&ctx.m_timer);
 
    scoped_lock lock(&ctx.m_mtx);
    ctx.m_pending = true;
 
    auto &radio = scl::board::get_instance().radio();
    /* Do DSP and send it! */
    auto crc = etl::crc32_c(ctx.m_tx_msg.data, ctx.m_tx_msg.data +
                                                   radio.tx_len(ctx.m_iface) -
                                                   sizeof(uint32_t))
                   .value();
    ctx.m_tx_msg.data[radio.tx_len(ctx.m_iface) - 4] = crc >> 24;
    ctx.m_tx_msg.data[radio.tx_len(ctx.m_iface) - 3] = crc >> 16;
    ctx.m_tx_msg.data[radio.tx_len(ctx.m_iface) - 2] = crc >> 8;
    ctx.m_tx_msg.data[radio.tx_len(ctx.m_iface) - 1] = crc;
 
    dsp::ccsds::scrambler(ctx.m_tx_msg.data, radio.tx_len(ctx.m_iface));
 
    radio.tx(ctx.m_iface, ctx.m_tx_msg.data);
    ctx.frame_sent(true);
 
    /*
     * Update the timer that allows the interface to stay in TX mode for the
     * configured amount of time to increase throughput
     */
    if (ctx.m_tx_wait) {
      uint32_t wait_ms = ctx.m_iface == scl::radio::interface::UHF
                             ? s.get<settings::param::UHF_TX_WAIT_MS>()
                             : s.get<settings::param::SBAND_TX_WAIT_MS>();
 
      k_timer_start(&ctx.m_timer, K_MSEC(wait_ms), K_NO_WAIT);
 
      ctx.m_pending = false;
      k_condvar_broadcast(&ctx.m_cond_var);
      return No_State_Change;
    } else {
      k_timer_stop(&ctx.m_timer);
      ctx.m_pending = false;
      k_condvar_broadcast(&ctx.m_cond_var);
      return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::RX);
    }
  }
  /* We can easily recover from the timeout exception */
  catch (const scl::timeout_exception &e) {
    ctx.frame_sent(false);
    auto &err = error_handler::get_instance();
    log.log({sc::logger::target::RTT},
            ctx.m_iface == scl::radio::interface::UHF
                ? "iface_ctrl<UHF>: Exception occurred"
                : "iface_ctrl<S-Band>: Exception occurred");
    err.handle(e);
    ctx.m_pending = false;
    k_condvar_broadcast(&ctx.m_cond_var);
    return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::RX);
  } catch (const scl::exception &e) {
    ctx.frame_sent(false);
    auto &err = error_handler::get_instance();
    log.log({sc::logger::target::RTT},
            ctx.m_iface == scl::radio::interface::UHF
                ? "iface_ctrl<UHF>: Exception occurred"
                : "iface_ctrl<S-Band>: Exception occurred");
    err.handle(e);
    ctx.m_pending = false;
    k_condvar_broadcast(&ctx.m_cond_var);
    return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::IDLE);
  }
}
 
etl::fsm_state_id_t
iface_ctrl::tx_state::on_event(const rx_msg &msg)
{
  auto &ctx = get_fsm_context();
  /*
   * NOTE: Disable first the timer to avoid accidental fireup while waiting for
   * the operation to finish
   */
  k_timer_stop(&ctx.m_timer);
  /* Let the final frame finish  */
  ctx.wait_pending_operation();
  return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::RX);
}
 
etl::fsm_state_id_t
iface_ctrl::tx_state::on_event_unknown(const etl::imessage &msg)
{
  auto &ctx = get_fsm_context();
  auto &log = sc::logger::get_instance();
  log.log({sc::logger::target::RTT},
          ctx.m_iface == scl::radio::interface::UHF
              ? "iface_ctrl<UHF>:TX state unknown msg"
              : "iface_ctrl<S-Band>: TX state unknown msg");
  return No_State_Change;
}
 
/*****************************************************************************
 *****************************************************************************
 ***************************** RX state handling *****************************
 *****************************************************************************
 *****************************************************************************/
 
etl::fsm_state_id_t
iface_ctrl::rx_state::on_enter_state()
{
  auto &ctx = get_fsm_context();
  auto &log = sc::logger::get_instance();
  try {
    /* Stop the timer we do not want to expire in the middle of an RX */
    k_timer_stop(&ctx.m_timer);
 
    log.log({sc::logger::target::RTT},
            ctx.m_iface == scl::radio::interface::UHF
                ? "iface_ctrl<UHF>: enter RX state"
                : "iface_ctrl<S-Band>: enter RX state");
    auto &radio = scl::board::get_instance().radio();
    auto &s     = settings::get_instance();
 
    /*
     * Force the interface to stop. This will close all the analog chain of the
     * AT86RF215. Note that if the radio in general is not enabled, this does
     * not make any sense.
     */
    if (radio.enabled()) {
      radio.stop(ctx.m_iface);
    }
 
    /*
     * If this is a transition from another state, apply the RX settings
     */
    radio.enable(ctx.m_iface);
 
    /* Get the RX configuration */
    lib::radio::rx_conf cnf;
    s.get_rx_conf(ctx.m_iface, cnf);
 
    radio.rx_async(ctx.m_iface, cnf);
 
    /*
     * Fireup the timer to enter IDLE mode. If any of the on or off periods are
     * set to 0, this mechanism is not activated and the transceiver will stay
     * at RX mode continuously or until a TX or disable event is requested
     */
    if (ctx.duty_cycle_enabled()) {
      uint32_t on_secs = ctx.m_iface == scl::radio::interface::UHF
                             ? s.get<settings::param::UHF_RX_ON_SECS>()
                             : s.get<settings::param::SBAND_RX_ON_SECS>();
      k_timer_start(&ctx.m_timer, K_SECONDS(on_secs), K_NO_WAIT);
    }
 
    return No_State_Change;
    /*
     * In case of a known error, we go to the disabled state. From there we may
     * recover
     */
  } catch (const scl::exception &e) {
    auto &err = error_handler::get_instance();
    log.log({sc::logger::target::RTT},
            ctx.m_iface == scl::radio::interface::UHF
                ? "iface_ctrl<UHF>: Exception occurred"
                : "iface_ctrl<S-Band>: Exception occurred");
    err.handle(e);
    return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::IDLE);
  }
}
 
etl::fsm_state_id_t
iface_ctrl::rx_state::on_event(const disable_msg &msg)
{
  auto &ctx = get_fsm_context();
  /*
   * NOTE: Disable first the timer to avoid accidental fireup while waiting for
   * the operation to finish
   */
  k_timer_stop(&ctx.m_timer);
  /* Let the final frame finish  */
  ctx.wait_pending_operation();
  return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::DISABLED);
}
 
etl::fsm_state_id_t
iface_ctrl::rx_state::on_event(const tx_frame_msg &msg)
{
  auto &ctx = get_fsm_context();
  auto &log = sc::logger::get_instance();
  try {
    /* Stop the timer we do not want to expire while we are waiting  */
    k_timer_stop(&ctx.m_timer);
 
    /*
     * Implement the GS TRX turnaround time taking also into account
     * the time from the last frame received and go to TX state
     */
    auto    &s        = settings::get_instance();
    uint32_t trx_time = ctx.m_iface == scl::radio::interface::UHF
                            ? s.get<settings::param::UHF_TRX_TURNAROUND_MS>()
                            : s.get<settings::param::SBAND_TRX_TURNAROUND_MS>();
    int64_t  now      = k_uptime_get();
    if (now - ctx.m_stats.last_rx_ts < trx_time) {
      k_msleep(etl::clamp<uint64_t>(trx_time - (now - ctx.m_stats.last_rx_ts),
                                    1U, MAX_TRX_MS));
    }
    return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::TX);
  } catch (const scl::exception &e) {
    log.log({sc::logger::target::RTT},
            ctx.m_iface == scl::radio::interface::UHF
                ? "iface_ctrl<UHF>: Exception occurred"
                : "iface_ctrl<S-Band>: Exception occurred");
    auto &err = error_handler::get_instance();
    err.handle(e);
    return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::IDLE);
  }
}
 
etl::fsm_state_id_t
iface_ctrl::rx_state::on_event(const idle_msg &msg)
{
  auto &ctx = get_fsm_context();
  k_timer_stop(&ctx.m_timer);
  /* Let the final frame finish  */
  ctx.wait_pending_operation();
  return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::IDLE);
}
 
etl::fsm_state_id_t
iface_ctrl::rx_state::on_event(const frame_received_msg &msg)
{
  auto &ctx = get_fsm_context();
  auto &s   = settings::get_instance();
  /* Just extend the ON period */
  if (ctx.duty_cycle_enabled()) {
    uint32_t on_secs = ctx.m_iface == scl::radio::interface::UHF
                           ? s.get<settings::param::UHF_RX_ON_SECS>()
                           : s.get<settings::param::SBAND_RX_ON_SECS>();
    k_timer_start(&ctx.m_timer, K_SECONDS(on_secs), K_NO_WAIT);
  }
  return No_State_Change;
}
 
etl::fsm_state_id_t
iface_ctrl::rx_state::on_event_unknown(const etl::imessage &msg)
{
  auto &ctx = get_fsm_context();
  auto &log = sc::logger::get_instance();
  log.log({sc::logger::target::RTT},
          ctx.m_iface == scl::radio::interface::UHF
              ? "iface_ctrl<UHF>: RX state unknown msg"
              : "iface_ctrl<S-Band>: RX state unknown msg");
  return No_State_Change;
}
 
/*****************************************************************************
 *****************************************************************************
 ***************************** IDLE state handling ***************************
 *****************************************************************************
 *****************************************************************************/
 
etl::fsm_state_id_t
iface_ctrl::idle_state::on_enter_state()
{
  auto &ctx = get_fsm_context();
  auto &log = sc::logger::get_instance();
  auto &s   = settings::get_instance();
  k_timer_stop(&ctx.m_timer);
 
  try {
    log.log({sc::logger::target::RTT},
            ctx.m_iface == scl::radio::interface::UHF
                ? "iface_ctrl<UHF>: enter IDLE state"
                : "iface_ctrl<S-Band>: enter IDLE state");
    auto &radio = scl::board::get_instance().radio();
    radio.stop(ctx.m_iface);
 
    /*
     * Make sure that the timer will fireup, even in the case somehow (race
     * condition?) the OFF period was erroneously set to 0. In addtion, we use
     * the IDLE state to recover from errors, so even if the OFF period is set
     * to 0 by the user, the recovery will be attempted after 1 second
     */
    uint32_t off_secs = ctx.m_iface == scl::radio::interface::UHF
                            ? s.get<settings::param::UHF_RX_OFF_SECS>()
                            : s.get<settings::param::SBAND_RX_OFF_SECS>();
    k_timer_start(&ctx.m_timer, K_SECONDS(std::max(1U, off_secs)), K_NO_WAIT);
 
    /*
     * In case of a known error, we stay at the same state. The re-enable timer
     * may allow to recover
     */
  } catch (const scl::exception &e) {
    log.log({sc::logger::target::RTT},
            ctx.m_iface == scl::radio::interface::UHF
                ? "iface_ctrl<UHF>: Exception occurred"
                : "iface_ctrl<S-Band>: Exception occurred");
    auto &err = error_handler::get_instance();
    err.handle(e);
    /* Similar approach as above */
    uint32_t off_secs = ctx.m_iface == scl::radio::interface::UHF
                            ? s.get<settings::param::UHF_RX_OFF_SECS>()
                            : s.get<settings::param::SBAND_RX_OFF_SECS>();
    k_timer_start(&ctx.m_timer, K_SECONDS(std::max(1U, off_secs)), K_NO_WAIT);
  }
  return No_State_Change;
}
 
void
iface_ctrl::idle_state::on_exit_state()
{
  /* Too pedantic but just in case! */
  auto &ctx = get_fsm_context();
  k_timer_stop(&ctx.m_timer);
}
 
etl::fsm_state_id_t
iface_ctrl::idle_state::on_event(const disable_msg &msg)
{
  auto &ctx = get_fsm_context();
  /*
   * NOTE: Disable first the timer to avoid accidental fireup while waiting for
   * the operation to finish
   */
  k_timer_stop(&ctx.m_timer);
  /* Let the final frame finish  */
  ctx.wait_pending_operation();
  return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::DISABLED);
}
 
etl::fsm_state_id_t
iface_ctrl::idle_state::on_event(const tx_frame_msg &msg)
{
  /* While idling a TX may requested. Go directly to TX state */
  return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::TX);
}
 
etl::fsm_state_id_t
iface_ctrl::idle_state::on_event(const rx_msg &msg)
{
  return static_cast<etl::fsm_state_id_t>(iface_ctrl::state::RX);
}
 
etl::fsm_state_id_t
iface_ctrl::idle_state::on_event_unknown(const etl::imessage &msg)
{
  auto &ctx = get_fsm_context();
  auto &log = sc::logger::get_instance();
  log.log({sc::logger::target::RTT},
          ctx.m_iface == scl::radio::interface::UHF
              ? "iface_ctrl<UHF>: RX state unknown msg"
              : "iface_ctrl<S-Band>: RX state unknown msg");
  return No_State_Change;
}
 
} // namespace satnogs::comms::utils