io.hpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS MCU software
 *
 *  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
 */
 
#pragma once
 
#include "callbacks.hpp"
#include "error_handler.hpp"
#include "msg_arbiter.hpp"
#include "settings.hpp"
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <etl/to_string.h>
#include <satnogs-comms-lib/board.hpp>
#include <satnogs-comms-lib/power.hpp>
#include <satnogs-comms-lib/radio.hpp>
#include <utils/iface_ctrl.hpp>
#include <zephyr/canbus/isotp.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/kernel.h>
#include <zephyr/task_wdt/task_wdt.h>
 
namespace scl = satnogs::comms::lib;
 
namespace satnogs::comms
{
 
class io
{
public:
  class uart
  {
  public:
    /* Reduce the memory footprint by using the bounching buffer option of the
     * async API*/
    static constexpr size_t buf_len = CONFIG_MAX_MTU / 2;
    enum class identifier : uint8_t
    {
      PC104
    };
 
    uart(identifier id) : id(id), buf_idx(0), msg_idx(0) {};
 
    const identifier id;
    uint8_t          buf_idx;
    uint32_t         msg_idx;
    uint8_t          buf[2][buf_len];
    msg_arbiter::msg msg;
  };
 
  class radio
  {
  public:
    friend io;
    radio()
        : m_uhf(scl::radio::interface::UHF),
          m_sband(scl::radio::interface::SBAND)
    {
      k_mutex_init(&m_mtx);
    }
 
    void
    enable()
    {
      scoped_lock lock(m_mtx);
      auto       &radio = scl::board::get_instance().radio();
      radio.enable();
      m_uhf.enable();
      m_sband.enable();
    }
 
    void
    enable(scl::radio::interface iface, bool yes = true)
    {
      scoped_lock lock(m_mtx);
      switch (iface) {
      case scl::radio::interface::UHF:
        m_uhf.enable(yes);
        break;
      case scl::radio::interface::SBAND:
        m_sband.enable(yes);
        break;
      default:
        return;
      }
    }
 
    void
    disable(scl::radio::interface iface)
    {
      enable(iface, false);
    }
 
    void
    disable()
    {
      scoped_lock lock(m_mtx);
      auto       &radio = scl::board::get_instance().radio();
      m_uhf.disable();
      m_sband.disable();
      radio.enable(false);
    }
 
    int
    rx(scl::radio::rx_msg &msg, uint32_t timeout_ms)
    {
      auto &radio = scl::board::get_instance().radio();
      return radio.recv_msg(msg, timeout_ms);
    }
 
    void
    tx(scl::radio::interface iface, const msg_arbiter::msg &msg,
       bool more = false)
    {
      scoped_lock lock(m_mtx);
      switch (iface) {
      case scl::radio::interface::UHF:
        m_uhf.tx(msg, more);
        break;
      case scl::radio::interface::SBAND:
        m_sband.tx(msg, more);
        break;
      default:
        return;
      }
    }
 
    void
    reset_stats(scl::radio::interface iface)
    {
      scoped_lock lock(m_mtx);
      switch (iface) {
      case scl::radio::interface::UHF:
        m_uhf.reset_stats();
        break;
      case scl::radio::interface::SBAND:
        m_sband.reset_stats();
        break;
      default:
        return;
      }
    }
 
    const utils::iface_ctrl &
    uhf()
    {
      return m_uhf;
    }
 
    const utils::iface_ctrl &
    sband()
    {
      return m_sband;
    }
 
  private:
    utils::iface_ctrl m_uhf;
    utils::iface_ctrl m_sband;
    struct k_mutex    m_mtx;
  };
 
  static io &
  get_instance()
  {
    static io instance;
    return instance;
  }
 
  /* Singleton */
  io(io const &) = delete;
 
  void
  operator=(io const &) = delete;
 
  radio &
  radio_ctrl();
 
  void
  start();
 
private:
  static void
  can1_tx_thread(void *arg1, void *arg2, void *arg3);
 
  static void
  can1_rx_thread(void *arg1, void *arg2, void *arg3);
 
  static void
  can2_rx_thread(void *arg1, void *arg2, void *arg3);
 
  static void
  can2_tx_thread(void *arg1, void *arg2, void *arg3);
 
  static void
  radio_rx_thread(void *arg1, void *arg2, void *arg3);
 
  static void
  uhf_tx_thread(void *arg1, void *arg2, void *arg3);
 
  static void
  sband_tx_thread(void *arg1, void *arg2, void *arg3);
 
  void
  radio_rx_drop_callback(scl::radio::interface iface);
 
  void
  update_radio_rx_stats(scl::radio::interface iface, bool valid, float rssi);
 
  io() = default;
 
  radio    m_radio;
  k_tid_t  m_can1_tx_tid;
  k_tid_t  m_can1_rx_tid;
  k_tid_t  m_can2_tx_tid;
  k_tid_t  m_can2_rx_tid;
  k_tid_t  m_radio_rx_tid;
  k_tid_t  m_uhf_tx_tid;
  k_tid_t  m_sband_tx_tid;
  uint32_t m_can1_rx_cnt;
  uint32_t m_can1_tx_cnt;
  uint32_t m_usart3_rx_cnt;
  uint32_t m_usart3_tx_cnt;
};
 
class can_enable_exception : public scl::exception
{
public:
  can_enable_exception(string_type file_name, numeric_type line)
      : scl::exception(
            scl::exception::severity::MAJOR, file_name, line,
            error_msg{"Could not enable CAN device", "canenbl", ECANENBL})
  {
  }
};
 
class isotp_bind_exception : public scl::exception
{
public:
  isotp_bind_exception(string_type file_name, numeric_type line)
      : scl::exception(scl::exception::severity::MINOR, file_name, line,
                       error_msg{"Could not bind the ISOTP device", "isotpbind",
                                 EISOTPBIND})
  {
  }
};
 
class isotp_recv_exception : public scl::exception
{
public:
  isotp_recv_exception(string_type file_name, numeric_type line)
      : scl::exception(scl::exception::severity::MINOR, file_name, line,
                       error_msg{"Could not receive from ISOTP device",
                                 "isotprecv", EISOTPRECV})
  {
  }
};
 
} // namespace satnogs::comms