iface_ctrl.hpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS MCU software
 *
 *  Copyright (C) 2025, 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 "unique_message_router_id.hpp"
#include <cstdint>
#include <etl/fsm.h>
#include <msg_arbiter.hpp>
#include <satnogs-comms-lib/radio.hpp>
 
namespace satnogs::comms::utils
{
 
class iface_ctrl : public etl::fsm
{
public:
  static constexpr uint32_t MAX_TRX_MS = 5000U;
 
  enum class state : uint8_t
  {
    DISABLED, 
    TX,       
    RX,       
    IDLE      
  };

  class stats
  {
  public:
    size_t tx_frames;        
    size_t tx_frames_fail;   
    size_t tx_frames_drop;   
    size_t rx_frames;        
    size_t rx_frames_inval;  
    size_t   rx_frames_drop; 
    uint64_t last_rx_ts;     
    float    last_rssi;      
    uint64_t last_valid_rx_ts; 
    float    last_valid_rssi;  
 
    stats()
        : tx_frames(0),
          tx_frames_fail(0),
          tx_frames_drop(0),
          rx_frames(0),
          rx_frames_inval(0),
          rx_frames_drop(0),
          last_rx_ts(0),
          last_rssi(std::nanf("nan")),
          last_valid_rx_ts(0),
          last_valid_rssi(std::nanf("nan"))
    {
    }
 
    void
    reset()
    {
      tx_frames        = 0;
      tx_frames_fail   = 0;
      tx_frames_drop   = 0;
      rx_frames        = 0;
      rx_frames_inval  = 0;
      rx_frames_drop   = 0;
      last_rx_ts       = 0;
      last_rssi        = std::nanf("nan");
      last_valid_rx_ts = 0;
      last_valid_rssi  = std::nanf("nan");
    }
  };
 
  iface_ctrl(satnogs::comms::lib::radio::interface iface);
 
  void
  enable();
 
  void
  enable(bool yes);
 
  void
  disable();
 
  void
  restart();
 
  void
  reset_stats();
 
  const stats &
  get_stats() const;
 
  void
  rx_frame_dropped();
 
  void
  frame_received(bool valid, float rssi);
 
  void
  tx(const msg_arbiter::msg &msg, bool more = false);
 
  iface_ctrl::state
  get_state() const;
 
  class disabled_exception : public satnogs::comms::lib::exception
  {
  public:
    disabled_exception(string_type file_name, numeric_type line)
        : satnogs::comms::lib::exception(
              satnogs::comms::lib::exception::severity::MINOR, file_name, line,
              error_msg{"Interface is disabled", "ifacedis", ERADIO})
    {
    }
  };
 
  class tx_inhibit_exception : public satnogs::comms::lib::exception
  {
  public:
    tx_inhibit_exception(string_type file_name, numeric_type line)
        : satnogs::comms::lib::exception(
              satnogs::comms::lib::exception::severity::MINOR, file_name, line,
              error_msg{"Interface has TX inhibit configured", "ifacetxinh",
                        ERADIO})
    {
    }
  };
 
private:
  const satnogs::comms::lib::radio::interface m_iface;
  bool                                        m_pending;
  k_mutex                                     m_mtx;
  struct k_condvar                            m_cond_var;
  k_timer                                     m_timer;
  struct k_work                               m_work;
  msg_arbiter::msg                            m_tx_msg;
  bool                                        m_tx_wait;

  enum events : uint8_t
  {
    ENABLE,         
    DISABLE,        
    TX_FRAME,       
    RX_MODE,        
    IDLE_MODE,      
    FRAME_RECEIVED, 
    RECONFIGURE     
  };
 
  // void
  // operation_start();
 
  // void
  // operation_stop();
 
  void
  wait_pending_operation();
 
  void
  frame_sent(bool success);
 
  void
  tx_frame_dropped();
 
  bool
  duty_cycle_enabled();
 
  static void
  timer_handler(k_timer *t);
 
  static void
  timer_work_handler(k_work *item);
 
  class disable_msg : public etl::message<events::DISABLE>
  {
  public:
    disable_msg() = default;
  };
 
  class tx_frame_msg : public etl::message<events::TX_FRAME>
  {
  public:
    tx_frame_msg() = default;
  };
 
  class rx_msg : public etl::message<events::RX_MODE>
  {
  public:
    rx_msg() = default;
  };
 
  class idle_msg : public etl::message<events::IDLE_MODE>
  {
  public:
    idle_msg() = default;
  };
 
  class frame_received_msg : public etl::message<events::FRAME_RECEIVED>
  {
  public:
    frame_received_msg() = default;
  };
 
  class disabled_state
      : public etl::fsm_state<iface_ctrl, disabled_state,
                              static_cast<etl::fsm_state_id_t>(state::DISABLED),
                              rx_msg, tx_frame_msg>
  {
  public:
    etl::fsm_state_id_t
    on_enter_state() override;
 
    etl::fsm_state_id_t
    on_event(const rx_msg &msg);
 
    etl::fsm_state_id_t
    on_event(const tx_frame_msg &msg);
 
    etl::fsm_state_id_t
    on_event_unknown(const etl::imessage &msg);
  };
 
  class tx_state
      : public etl::fsm_state<iface_ctrl, tx_state,
                              static_cast<etl::fsm_state_id_t>(state::TX),
                              disable_msg, tx_frame_msg, rx_msg>
  {
  public:
    etl::fsm_state_id_t
    on_enter_state() override;
 
    void
    on_exit_state() override;
 
    etl::fsm_state_id_t
    on_event(const disable_msg &msg);
 
    etl::fsm_state_id_t
    on_event(const tx_frame_msg &msg);
 
    etl::fsm_state_id_t
    on_event(const rx_msg &msg);
 
    etl::fsm_state_id_t
    on_event_unknown(const etl::imessage &msg);
  };
 
  class rx_state
      : public etl::fsm_state<
            iface_ctrl, rx_state, static_cast<etl::fsm_state_id_t>(state::RX),
            disable_msg, tx_frame_msg, idle_msg, frame_received_msg>
  {
  public:
    etl::fsm_state_id_t
    on_enter_state() override;
 
    etl::fsm_state_id_t
    on_event(const disable_msg &msg);
 
    etl::fsm_state_id_t
    on_event(const tx_frame_msg &msg);
 
    etl::fsm_state_id_t
    on_event(const idle_msg &msg);
 
    etl::fsm_state_id_t
    on_event(const frame_received_msg &msg);
 
    etl::fsm_state_id_t
    on_event_unknown(const etl::imessage &msg);
  };
 
  class idle_state
      : public etl::fsm_state<iface_ctrl, idle_state,
                              static_cast<etl::fsm_state_id_t>(state::IDLE),
                              disable_msg, tx_frame_msg, rx_msg>
  {
  public:
    etl::fsm_state_id_t
    on_enter_state() override;
 
    void
    on_exit_state() override;
 
    etl::fsm_state_id_t
    on_event(const disable_msg &msg);
 
    etl::fsm_state_id_t
    on_event(const tx_frame_msg &msg);
 
    etl::fsm_state_id_t
    on_event(const rx_msg &msg);
 
    etl::fsm_state_id_t
    on_event_unknown(const etl::imessage &msg);
  };
 
private:
  disabled_state   m_disabled_state;
  tx_state         m_tx_state;
  rx_state         m_rx_state;
  idle_state       m_idle_state;
  etl::ifsm_state *m_state_list[4];
  stats            m_stats;
};
} // namespace satnogs::comms::utils