telecommand.cpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS MCU software
 *
 *  Copyright (C) 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
 */
 
#include "telecommand.hpp"
#include "error_handler.hpp"
#include "io.hpp"
#include "io_wdg.hpp"
#include "memory_monitor.hpp"
#include "ota.hpp"
#include "settings.hpp"
#include "storage.hpp"
#include "telemetry.hpp"
#include "time.hpp"
#include <etl/bit_stream.h>
 
namespace satnogs::comms
{
 
void
telecommand::deserialize(etl::bit_stream_reader &reader, float &x)
{
  uint32_t float_bits = reader.read<uint32_t>(32).value();
  std::memcpy(&x, &float_bits, sizeof(float_bits));
}
 
void
telecommand::deserialize(etl::bit_stream_reader &reader, double &x)
{
  uint64_t double_bits = reader.read<uint64_t>(64).value();
  std::memcpy(&x, &double_bits, sizeof(double_bits));
}
 
bool
telecommand::ccsds_frame_valid(const uint8_t *b, size_t len)
{
  etl::bit_stream_reader       bit_stream(etl::span(b, len), etl::endian::big);
  telecommand::ccsds_tc_header tc_header;
  tc_header.deserialize(bit_stream);
 
  /* FIXME: frame checking needs revising */
  if ((tc_header.version != 0) && (tc_header.sec_hdr != 0) &&
      (tc_header.group_flags != 0b11)) {
    return false;
  } else {
    return true;
  }
}
 
int
telecommand::get_frame_count()
{
  return m_frame_count;
}
 
bool
telecommand::parse_ring_buffer_logs(msg_arbiter::msg       &m,
                                    etl::bit_stream_reader &bit_stream)
{
  uint32_t num_of_logs = bit_stream.read<uint32_t>(32).value();
  telemetry::send_ring_buffer_logs_tlm(m, num_of_logs);
  return false;
}
 
bool
telecommand::parse_tlm_req(msg_arbiter::msg       &m,
                           etl::bit_stream_reader &bit_stream)
{
  telemetry::apid tlm_type;
  tlm_type =
      static_cast<telemetry::apid>(bit_stream.read<uint16_t>(16).value());
  switch (tlm_type) {
  case telemetry::apid::BASIC:
    telemetry::tlm<telemetry::apid::BASIC>(m);
    break;
  case telemetry::apid::POWER:
    telemetry::tlm<telemetry::apid::POWER>(m);
    break;
  case telemetry::apid::HEALTH:
    telemetry::tlm<telemetry::apid::HEALTH>(m);
    break;
  case telemetry::apid::CONFIG:
    telemetry::tlm<telemetry::apid::CONFIG>(m);
    break;
  case telemetry::apid::FPGA:
    telemetry::tlm<telemetry::apid::FPGA>(m);
    break;
  case telemetry::apid::RADIO:
    telemetry::tlm<telemetry::apid::RADIO>(m);
    break;
  case telemetry::apid::TIME:
    telemetry::tlm<telemetry::apid::TIME>(m);
    break;
  case telemetry::apid::BOOTLOADER_INFO:
    telemetry::tlm<telemetry::apid::BOOTLOADER_INFO>(m);
    break;
  case telemetry::apid::STORAGE_STATUS: {
    telemetry::tlm<telemetry::apid::STORAGE_STATUS>(m);
  } break;
  case telemetry::apid::SETTINGS:
    telemetry::tlm<telemetry::apid::SETTINGS>(m);
    break;
  case telemetry::apid::OTA_SESSION_INFO: {
    telemetry::send_all_ota_sessions_info_tlm(m);
    return false;
  }
  default:
    return false;
  }
  return true;
}
 
bool
telecommand::parse_storage_tlm(msg_arbiter::msg       &m,
                               etl::bit_stream_reader &reader, packet_id id)
{
  switch (id) {
  case packet_id::STORAGE_LS: {
    telecommand::prefixed_string path;
    path.deserialize(reader);
    telemetry::tlm<telemetry::apid::STORAGE_LS_RESP>(m, path.value);
  } break;
 
  case packet_id::STORAGE_READ: {
    telecommand::prefixed_string path;
    path.deserialize(reader);
    size_t offset = reader.read<size_t>(32).value();
    size_t len    = reader.read<size_t>(32).value();
    if (len == 0) {
      len = CONFIG_MAX_MTU;
    }
    telemetry::tlm<telemetry::apid::STORAGE_READ_RESP>(m, path.value, offset,
                                                       len);
  } break;
  case packet_id::STORAGE_FSTATS: {
    telecommand::prefixed_string path;
    path.deserialize(reader);
    telemetry::tlm<telemetry::apid::STORAGE_FSTATS_RESP>(m, path.value);
  } break;
  default:
    return false;
  }
  return true;
}
 
telecommand::telecommand() : m_frame_count(0) {}
 
template <> class telecommand::parser<telecommand::packet_id::TEST_TX_SIMPLE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    auto                                          &t = test::get_instance();
    parser<telecommand::packet_id::TEST_TX_SIMPLE> req;
    req.deserialize(bit_stream);
    switch (req.iface) {
    case static_cast<uint32_t>(lib::radio::interface::UHF):
      t.exec_test(test::test_id::TX_UHF_SIMPLE,
                  {req.nframes, req.delay_us, req.len});
      break;
    case static_cast<uint32_t>(lib::radio::interface::SBAND):
      t.exec_test(test::test_id::TX_SBAND_SIMPLE,
                  {req.nframes, req.delay_us, req.len});
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  uint32_t iface;
  uint32_t nframes;
  uint32_t delay_us;
  uint32_t len;
  parser() : iface(0), nframes(0), delay_us(0), len(0) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface    = reader.read<uint32_t>(1).value();
    nframes  = reader.read<uint32_t>(32).value();
    delay_us = reader.read<uint32_t>(32).value();
    len      = reader.read<uint32_t>(32).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::TESTS_STOP>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    auto &t = test::get_instance();
    t.stop();
    return true;
  }
 
private:
  bool yes;
  parser() : yes(true) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    yes = reader.read<uint8_t>(1).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::FPGA_ENABLE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::FPGA_ENABLE> req;
    req.deserialize(bit_stream);
    auto &fpga = lib::board::get_instance().fpga();
    if (req.enable_fpga) {
      fpga.enable(true);
    } else {
      fpga.enable(false);
    }
    return true;
  }
 
private:
  bool enable_fpga;
  parser() : enable_fpga(false) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    enable_fpga = reader.read<uint8_t>(1).value();
  }
};
 
template <>
class telecommand::parser<telecommand::packet_id::SET_FLASH_MONITOR_DELAY_SEC>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_FLASH_MONITOR_DELAY_SEC> req;
    req.deserialize(bit_stream);
    auto &mem_mon = memory_monitor::get_instance();
 
    if (req.flash_mon_delay_sec == 0) {
      mem_mon.stop();
    } else {
      mem_mon.start(etl::clamp(req.flash_mon_delay_sec, 1U, 21600U));
    }
    return true;
  }
 
private:
  uint32_t flash_mon_delay_sec;
  parser() : flash_mon_delay_sec(0) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    flash_mon_delay_sec = reader.read<uint32_t>(32).value();
  }
};
template <> class telecommand::parser<telecommand::packet_id::STORAGE_ENABLE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::STORAGE_ENABLE> req;
    req.deserialize(bit_stream);
    auto &storage = storage::get_instance();
    storage.enable(req.enable_storage);
    return true;
  }
 
private:
  bool enable_storage;
  parser() : enable_storage(false) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    enable_storage = reader.read<uint8_t>(1).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::STORAGE_DIRECTION>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::STORAGE_DIRECTION> req;
    req.deserialize(bit_stream);
    auto &storage = storage::get_instance();
    storage.enable(true);
 
    switch (req.dir) {
    case telecommand::storage_direction::MCU: {
      storage.set_dir(lib::emmc::dir::MCU);
      return true;
    }
    case telecommand::storage_direction::FPGA: {
      storage.set_dir(lib::emmc::dir::FPGA);
      return true;
    }
    default:
      return false;
    }
  }
 
private:
  storage_direction dir;
  parser() : dir(storage_direction::MCU) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    dir = static_cast<storage_direction>(reader.read<uint8_t>(1).value());
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::STOP_WDT_UPDATE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::STOP_WDT_UPDATE> req;
    req.deserialize(bit_stream);
    if (req.stop_wdt_update) {
      k_msleep(CONFIG_WATCHDOG_PERIOD_SYS + 1000);
    }
    return true;
  }
 
private:
  bool stop_wdt_update;
  parser() : stop_wdt_update(false) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    stop_wdt_update = reader.read<uint8_t>(1).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::FREQ_SET>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::FREQ_SET> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    if (req.iface == lib::radio::interface::UHF &&
        req.direction == lib::rf_frontend::dir::RX) {
      s.set<settings::param::UHF_RX_FREQ>(req.freq);
    } else if (req.iface == lib::radio::interface::UHF &&
               req.direction == lib::rf_frontend::dir::TX) {
      s.set<settings::param::UHF_TX_FREQ>(req.freq);
    } else if (req.iface == lib::radio::interface::SBAND &&
               req.direction == lib::rf_frontend::dir::RX) {
      s.set<settings::param::SBAND_RX_FREQ>(req.freq);
    } else if (req.iface == lib::radio::interface::SBAND &&
               req.direction == lib::rf_frontend::dir::TX) {
      s.set<settings::param::SBAND_TX_FREQ>(req.freq);
    } else {
      return false;
    }
    return true;
  }
 
private:
  lib::rf_frontend::dir direction;
  lib::radio::interface iface;
  uint32_t              freq;
  parser()
      : direction(lib::rf_frontend::dir::RX),
        iface(lib::radio::interface::UHF),
        freq(0U)
  {
  }
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    direction =
        static_cast<lib::rf_frontend::dir>(reader.read<uint8_t>(2).value());
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    freq  = reader.read<uint32_t>(32).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::TX_INHIBIT>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::TX_INHIBIT> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_TX_EN>(!req.enable);
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_TX_EN>(!req.enable);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  bool                  enable;
  parser() : iface(lib::radio::interface::UHF), enable(false) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    enable = reader.read<uint8_t>(1).value();
  }
};
 
template <>
class telecommand::parser<telecommand::packet_id::SET_TX_GS_TURNAROUND_TIME>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_TX_GS_TURNAROUND_TIME> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_TRX_TURNAROUND_MS>(
          etl::clamp<uint32_t>(req.time_ms, 0U, utils::iface_ctrl::MAX_TRX_MS));
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_TRX_TURNAROUND_MS>(
          etl::clamp<uint32_t>(req.time_ms, 0U, utils::iface_ctrl::MAX_TRX_MS));
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  uint32_t              time_ms;
  parser() : iface(lib::radio::interface::UHF), time_ms(0U) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    time_ms = reader.read<uint32_t>(32).value();
  }
};
 
template <>
class telecommand::parser<telecommand::packet_id::RESET_ALL_OTA_SESSIONS>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    auto &ota = ota::get_instance();
    ota.reset_sessions();
    return true;
  }
 
private:
  parser() = default;
};
 
template <> class telecommand::parser<telecommand::packet_id::CONFIRM_IMAGE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    auto &ota = ota::get_instance();
    ota.confirm_image();
    return true;
  }
 
private:
  parser() = default;
};
 
template <> class telecommand::parser<telecommand::packet_id::RESET_OTA_SESSION>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::RESET_OTA_SESSION> req;
    req.deserialize(bit_stream);
    auto &ota = ota::get_instance();
    ota.reset_session(req.idx);
    return true;
  }
 
private:
  uint32_t idx;
  parser() : idx(0U) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    idx = reader.read<uint32_t>(32).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_RADIO_ENABLE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_RADIO_ENABLE> req;
    req.deserialize(bit_stream);
    auto &radio_ctrl = io::get_instance().radio_ctrl();
    switch (req.iface) {
    case lib::radio::interface::UHF:
    case lib::radio::interface::SBAND:
      radio_ctrl.enable(req.iface, req.enable);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  bool                  enable;
  parser() : iface(lib::radio::interface::UHF), enable(false) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    enable = reader.read<uint8_t>(1).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::TX_GAIN>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::TX_GAIN> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    switch (req.iface) {
    case satnogs::comms::lib::radio::interface::UHF:
      s.set<settings::param::UHF_TX_GAIN>(req.gain);
      break;
    case satnogs::comms::lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_TX_GAIN>(req.gain);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  float                 gain;
  parser() : iface(lib::radio::interface::UHF), gain(0.0f) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    telecommand::deserialize(reader, gain);
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::IO_WDT_PERIOD>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::IO_WDT_PERIOD> req;
    req.deserialize(bit_stream);
    auto &wdg = io_wdg::get_instance();
    wdg.set_period(req.period_mins);
    return true;
  }
 
private:
  uint32_t period_mins;
  parser() : period_mins(0) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    period_mins = reader.read<uint32_t>(32).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_RX_GAIN_MODE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_RX_GAIN_MODE> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF: {
      s.set<settings::param::UHF_GAIN0_MODE>(req.gain0_mode);
      s.set<settings::param::UHF_GAIN1_MODE>(req.gain1_mode);
    } break;
    case lib::radio::interface::SBAND: {
      s.set<settings::param::SBAND_GAIN0_MODE>(req.gain0_mode);
      s.set<settings::param::SBAND_GAIN1_MODE>(req.gain1_mode);
    } break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface       iface;
  lib::rf_frontend::gain_mode gain0_mode;
  lib::rf_frontend::gain_mode gain1_mode;
  parser()
      : iface(lib::radio::interface::UHF),
        gain0_mode(lib::rf_frontend::gain_mode::AUTO),
        gain1_mode(lib::rf_frontend::gain_mode::AUTO)
  {
  }
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    gain0_mode = static_cast<lib::rf_frontend::gain_mode>(
        reader.read<uint8_t>(1).value());
    gain1_mode = static_cast<lib::rf_frontend::gain_mode>(
        reader.read<uint8_t>(1).value());
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::EMMC_TEST>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::EMMC_TEST> req;
    req.deserialize(bit_stream);
    auto &t = test::get_instance();
    t.exec_test(test::test_id::EMMC_SIMPLE, {req.nbytes});
    return true;
  }
 
private:
  uint32_t nbytes;
  parser() : nbytes(0) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    nbytes = reader.read<uint32_t>(32).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::RESET_RADIO_STATS>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::RESET_RADIO_STATS> req;
    req.deserialize(bit_stream);
    io::get_instance().radio_ctrl().reset_stats(req.iface);
    return true;
  }
 
private:
  lib::radio::interface iface;
  parser() : iface(lib::radio::interface::UHF) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_RFFE_PARAMS>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_RFFE_PARAMS> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_RX_RANGE_MIN>(req.rx_range_min);
      s.set<settings::param::UHF_RX_RANGE_MAX>(req.rx_range_max);
      s.set<settings::param::UHF_TX_RANGE_MIN>(req.tx_range_min);
      s.set<settings::param::UHF_TX_RANGE_MAX>(req.tx_range_max);
      s.set<settings::param::UHF_AGC0_RANGE_MIN>(req.agc0_range_min);
      s.set<settings::param::UHF_AGC0_RANGE_MAX>(req.agc0_range_max);
      s.set<settings::param::UHF_GAIN0_RANGE_MIN>(req.gain0_range_min);
      s.set<settings::param::UHF_GAIN0_RANGE_MAX>(req.gain0_range_max);
      s.set<settings::param::UHF_AGC0_CALIB_SLOPE>(req.agc0_calib_slope);
      s.set<settings::param::UHF_AGC0_CALIB_INTRCPT>(req.agc0_calib_intrcpt);
      s.set<settings::param::UHF_GAIN0_CALIB_SLOPE>(req.gain0_calib_slope);
      s.set<settings::param::UHF_GAIN0_CALIB_INTRCPT>(req.gain0_calib_intrcpt);
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_RX_RANGE_MIN>(req.rx_range_min);
      s.set<settings::param::SBAND_RX_RANGE_MAX>(req.rx_range_max);
      s.set<settings::param::SBAND_TX_RANGE_MIN>(req.tx_range_min);
      s.set<settings::param::SBAND_TX_RANGE_MAX>(req.tx_range_max);
      s.set<settings::param::SBAND_AGC0_RANGE_MIN>(req.agc0_range_min);
      s.set<settings::param::SBAND_AGC0_RANGE_MAX>(req.agc0_range_max);
      s.set<settings::param::SBAND_GAIN0_RANGE_MIN>(req.gain0_range_min);
      s.set<settings::param::SBAND_GAIN0_RANGE_MAX>(req.gain0_range_max);
      s.set<settings::param::SBAND_AGC0_CALIB_SLOPE>(req.agc0_calib_slope);
      s.set<settings::param::SBAND_AGC0_CALIB_INTRCPT>(req.agc0_calib_intrcpt);
      s.set<settings::param::SBAND_GAIN0_CALIB_SLOPE>(req.gain0_calib_slope);
      s.set<settings::param::SBAND_GAIN0_CALIB_INTRCPT>(
          req.gain0_calib_intrcpt);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  uint32_t              rx_range_min;
  uint32_t              rx_range_max;
  uint32_t              tx_range_min;
  uint32_t              tx_range_max;
  float                 agc0_range_min;
  float                 agc0_range_max;
  float                 gain0_range_min;
  float                 gain0_range_max;
  float                 agc0_calib_slope;
  float                 agc0_calib_intrcpt;
  float                 gain0_calib_slope;
  float                 gain0_calib_intrcpt;
 
  parser()
      : iface(lib::radio::interface::UHF),
        rx_range_min(0U),
        rx_range_max(0U),
        tx_range_min(0U),
        tx_range_max(0U),
        agc0_range_min(0.0f),
        agc0_range_max(0.0f),
        gain0_range_min(0.0f),
        gain0_range_max(0.0f),
        agc0_calib_slope(0.0f),
        agc0_calib_intrcpt(0.0f),
        gain0_calib_slope(0.0f),
        gain0_calib_intrcpt(0.0f)
  {
  }
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    rx_range_min = reader.read<uint32_t>(32).value();
    rx_range_max = reader.read<uint32_t>(32).value();
    tx_range_min = reader.read<uint32_t>(32).value();
    tx_range_max = reader.read<uint32_t>(32).value();
    telecommand::deserialize(reader, agc0_range_min);
    telecommand::deserialize(reader, agc0_range_max);
    telecommand::deserialize(reader, gain0_range_min);
    telecommand::deserialize(reader, gain0_range_max);
    telecommand::deserialize(reader, agc0_calib_slope);
    telecommand::deserialize(reader, agc0_calib_intrcpt);
    telecommand::deserialize(reader, gain0_calib_slope);
    telecommand::deserialize(reader, gain0_calib_intrcpt);
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_RTC>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_RTC> req;
    req.deserialize(bit_stream);
    auto &time = satnogs::comms::time::get_instance();
    /* Make the appropriate adjustments from human readable to tm representation
     */
    struct tm t = {.tm_sec  = req.secs,
                   .tm_min  = req.mins,
                   .tm_hour = req.hour,
                   .tm_mday = req.day,
                   .tm_mon  = req.month - 1,
                   .tm_year = req.year - 1900};
    time.set(t);
    scl::exception e(scl::exception::severity::CRITICAL, __FILE__, __LINE__,
                     {"test", "t", 1});
    auto          &log = logger::get_instance();
    log.log(e);
    return true;
  }
 
private:
  uint8_t  secs;
  uint8_t  mins;
  uint8_t  hour;
  uint8_t  day;
  uint8_t  month;
  uint16_t year;
 
  parser() = default;
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    secs  = reader.read<uint8_t>(8).value();
    mins  = reader.read<uint8_t>(8).value();
    hour  = reader.read<uint8_t>(8).value();
    day   = reader.read<uint8_t>(8).value();
    month = reader.read<uint8_t>(8).value();
    year  = reader.read<uint16_t>(16).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_PLL_CLK_SRC>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_PLL_CLK_SRC> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    s.set<settings::param::PLL_REF_CLK_SRC>(static_cast<uint32_t>(req.src));
    /* Apply also ASAP the requested clock source */
    auto &radio = lib::board::get_instance().radio();
    radio.set_clk_src(req.src);
    return true;
  }
 
private:
  lib::radio::clk_src src;
  parser() : src(lib::radio::clk_src::INTERNAL) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    src = static_cast<lib::radio::clk_src>(reader.read<uint8_t>(1).value());
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_FILTER>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_FILTER> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_FILTER>(req.filter);
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_FILTER>(req.filter);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface    iface;
  lib::rf_frontend::filter filter;
  parser()
      : iface(lib::radio::interface::UHF),
        filter(lib::rf_frontend::filter::WIDE)
  {
  }
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    filter =
        static_cast<lib::rf_frontend::filter>(reader.read<uint8_t>(1).value());
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::REBOOT>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    auto &err = error_handler::get_instance();
    err.system_reboot();
    return true;
  }
 
private:
  parser() = default;
};
 
template <> class telecommand::parser<telecommand::packet_id::RESET_SETTINGS>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
 
    auto &s = settings::get_instance();
    s.reset_all();
    return true;
  }
 
private:
  parser() = default;
};
 
template <> class telecommand::parser<telecommand::packet_id::STORAGE_RM>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    telecommand::prefixed_string path;
    path.deserialize(bit_stream);
    auto &storage = storage::get_instance();
    storage.rm(path.value);
    return true;
  }
 
private:
  parser() = default;
};
 
template <> class telecommand::parser<telecommand::packet_id::STORAGE_RMDIR>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    telecommand::prefixed_string path;
    path.deserialize(bit_stream);
    auto &storage = storage::get_instance();
    storage.rmdir(path.value);
    return true;
  }
 
private:
  parser() = default;
};
 
template <> class telecommand::parser<telecommand::packet_id::STORAGE_MKDIR>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    telecommand::prefixed_string path;
    path.deserialize(bit_stream);
    auto &storage = storage::get_instance();
    storage.mkdir(path.value);
    return true;
  }
 
private:
  parser() = default;
};
 
template <> class telecommand::parser<telecommand::packet_id::STORAGE_WRITE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    telecommand::prefixed_string path;
    path.deserialize(bit_stream);
    parser<telecommand::packet_id::STORAGE_WRITE> data_length;
    data_length.deserialize(bit_stream);
    size_t offset = telecommand::ccsds_tc_header::size + sizeof(path.length) +
                    path.length + sizeof(data_length.data_length);
    auto &storage = storage::get_instance();
    storage.write(path.value, (uint8_t *)(bit_stream.begin() + offset),
                  data_length.data_length);
    return true;
  }
 
private:
  size_t data_length;
  parser() : data_length(0) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
 
    data_length = reader.read<uint32_t>(32).value();
  }
};
 
template <>
class telecommand::parser<telecommand::packet_id::STORAGE_WRITE_OFFSET>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    telecommand::prefixed_string path;
    path.deserialize(bit_stream);
 
    parser<telecommand::packet_id::STORAGE_WRITE_OFFSET> off_len;
    off_len.deserialize(bit_stream);
    size_t offset = telecommand::ccsds_tc_header::size + sizeof(path.length) +
                    path.length + sizeof(off_len.offset) +
                    sizeof(off_len.data_length);
    auto &storage = storage::get_instance();
    storage.write(path.value, (uint8_t *)(bit_stream.begin() + offset),
                  off_len.data_length, off_len.offset);
    return true;
  }
 
private:
  size_t offset;
  size_t data_length;
  parser() : offset(0), data_length(0) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    offset      = reader.read<uint32_t>(32).value();
    data_length = reader.read<uint32_t>(32).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SAVE_SETTINGS>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
 
    auto &s = settings::get_instance();
    s.save();
    return true;
  }
 
private:
  parser() = default;
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_AGC0_CONF>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_AGC0_CONF> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_GAIN0_TGT>(req.target);
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_GAIN0_TGT>(req.target);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  float                 target;
  parser() : iface(lib::radio::interface::UHF), target(0.0f) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    telecommand::deserialize(reader, target);
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_AGC1_CONF>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_AGC1_CONF> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_GAIN1_AGC>(req.cnf);
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_GAIN1_AGC>(req.cnf);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  settings::agc1        cnf;
  parser() : iface(lib::radio::interface::UHF) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    cnf.avg =
        static_cast<at86rf215_agc_avgs_t>(reader.read<uint8_t>(2).value());
    cnf.input = reader.read<uint8_t>(1).value();
    cnf.tgt = static_cast<at86rf215_agc_tgt_t>(reader.read<uint8_t>(3).value());
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_GAIN0_CONF>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_GAIN0_CONF> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_GAIN0_GAIN>(req.gain);
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_GAIN0_GAIN>(req.gain);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  float                 gain;
  parser() : iface(lib::radio::interface::UHF), gain(0.0f) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
 
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    telecommand::deserialize(reader, gain);
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_GAIN1_CONF>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_GAIN1_CONF> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_GAIN1_GAIN>(req.gain);
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_GAIN1_GAIN>(req.gain);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  float                 gain;
  parser() : iface(lib::radio::interface::UHF), gain(0.0f) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
 
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    telecommand::deserialize(reader, gain);
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_MODULATION>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_MODULATION> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    if (req.iface == lib::radio::interface::UHF &&
        req.direction == lib::rf_frontend::dir::RX) {
      s.set<settings::param::UHF_RX_MODULATION>(req.modulation);
    } else if (req.iface == lib::radio::interface::UHF &&
               req.direction == lib::rf_frontend::dir::TX) {
      s.set<settings::param::UHF_TX_MODULATION>(req.modulation);
    } else if (req.iface == lib::radio::interface::SBAND &&
               req.direction == lib::rf_frontend::dir::RX) {
      s.set<settings::param::SBAND_RX_MODULATION>(req.modulation);
    } else if (req.iface == lib::radio::interface::SBAND &&
               req.direction == lib::rf_frontend::dir::TX) {
      s.set<settings::param::SBAND_TX_MODULATION>(req.modulation);
    } else {
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface  iface;
  lib::rf_frontend::dir  direction;
  lib::radio::modulation modulation;
  parser()
      : iface(lib::radio::interface::UHF),
        direction(lib::rf_frontend::dir::RX),
        modulation(lib::radio::modulation::FSK)
  {
  }
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    direction =
        static_cast<lib::rf_frontend::dir>(reader.read<uint8_t>(2).value());
    modulation =
        static_cast<lib::radio::modulation>(reader.read<uint8_t>(3).value());
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_TX_FSK_CONF>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_TX_FSK_CONF> req;
    req.deserialize(bit_stream);
 
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_FSK_TX>(req.cnf);
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_FSK_TX>(req.cnf);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  settings::fsk         cnf;
  parser() : iface(lib::radio::interface::UHF) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    cnf.baudrate =
        static_cast<at86rf215_fsk_srate_t>(reader.read<uint8_t>(3).value());
    telecommand::deserialize(reader, cnf.mod_idx);
    telecommand::deserialize(reader, cnf.shaping);
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_RX_FSK_CONF>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_RX_FSK_CONF> req;
    req.deserialize(bit_stream);
 
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_FSK_RX>(req.cnf);
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_FSK_RX>(req.cnf);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  settings::fsk         cnf;
  parser() : iface(lib::radio::interface::UHF) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    cnf.baudrate =
        static_cast<at86rf215_fsk_srate_t>(reader.read<uint8_t>(3).value());
    telecommand::deserialize(reader, cnf.mod_idx);
    cnf.shaping = 1.0f;
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::DISK_RAW_WRITE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
 
    /* Deserialize starting sector and data length */
    parser<telecommand::packet_id::DISK_RAW_WRITE> tlc;
    tlc.deserialize(bit_stream);
 
    auto  &storage = storage::get_instance();
    size_t sent =
        storage.write_raw(tlc.buffer, tlc.starting_sector, tlc.data_length);
 
    if (sent < tlc.data_length) {
      return false;
    }
    return true;
  }
 
private:
  uint32_t       starting_sector;
  uint32_t       data_length;
  const uint8_t *buffer;
 
  parser() : starting_sector(0), data_length(0) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    starting_sector = reader.read<uint32_t>(32).value();
    data_length     = reader.read<uint32_t>(32).value();
    /* Buffer starts after the CCSDS header and the two 32-bit */
    buffer = reinterpret_cast<const uint8_t *>(
        reader.cbegin() + telecommand::ccsds_tc_header::size +
        sizeof(starting_sector) + sizeof(data_length));
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::DISK_RAW_READ>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
 
    /* Deserialize starting sector and data length */
    parser<telecommand::packet_id::DISK_RAW_READ> tlc;
    tlc.deserialize(bit_stream);
 
    telemetry::tlm<telemetry::apid::DISK_RAW_READ_RESP>(m, tlc.starting_sector,
                                                        tlc.sectors);
    return true;
  }
 
private:
  uint32_t starting_sector;
  uint32_t sectors;
  parser() : starting_sector(0), sectors(0) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    starting_sector = reader.read<uint32_t>(32).value();
    sectors         = reader.read<uint32_t>(32).value();
  }
};
 
template <>
class telecommand::parser<telecommand::packet_id::DISK_SECTORS_ERASE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
 
    /* Deserialize starting sector and data length */
    parser<telecommand::packet_id::DISK_SECTORS_ERASE> tlc;
    tlc.deserialize(bit_stream);
 
    auto &storage = storage::get_instance();
    storage.erase_sectors(tlc.starting_sector, tlc.sectors);
    return true;
  }
 
private:
  uint32_t starting_sector;
  uint32_t sectors;
  parser() : starting_sector(0), sectors(0) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    starting_sector = reader.read<uint32_t>(32).value();
    sectors         = reader.read<uint32_t>(32).value();
  }
};
 
template <>
class telecommand::parser<telecommand::packet_id::SET_THERMAL_MONITOR_PARAMS>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_THERMAL_MONITOR_PARAMS> req;
    req.deserialize(bit_stream);
    auto &s = settings::get_instance();
    s.set<settings::param::THERMAL_UHF_SHUTDOWN_TEMP>(
        req.uhf_shutdown_temperature);
    s.set<settings::param::THERMAL_UHF_ENABLE_TEMP>(req.uhf_enable_temperature);
    s.set<settings::param::THERMAL_SBAND_SHUTDOWN_TEMP>(
        req.sband_shutdown_temperature);
    s.set<settings::param::THERMAL_SBAND_ENABLE_TEMP>(
        req.sband_enable_temperature);
    s.set<settings::param::THERMAL_PCB_SHUTDOWN_TEMP>(
        req.pcb_shutdown_temperature);
    s.set<settings::param::THERMAL_PCB_ENABLE_TEMP>(req.pcb_enable_temperature);
    s.set<settings::param::THERMAL_MIN_VALID_TEMP>(req.min_valid_temperature);
    s.set<settings::param::THERMAL_MAX_VALID_TEMP>(req.max_valid_temperature);
    return true;
  }
 
private:
  float uhf_shutdown_temperature;
  float uhf_enable_temperature;
  float sband_shutdown_temperature;
  float sband_enable_temperature;
  float pcb_shutdown_temperature;
  float pcb_enable_temperature;
  float min_valid_temperature;
  float max_valid_temperature;
  parser()
      : uhf_shutdown_temperature(0.0f),
        uhf_enable_temperature(0.0f),
        sband_shutdown_temperature(0.0f),
        sband_enable_temperature(0.0f),
        pcb_shutdown_temperature(0.0f),
        pcb_enable_temperature(0.0f),
        min_valid_temperature(0.0f),
        max_valid_temperature(0.0f)
  {
  }
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    telecommand::deserialize(reader, uhf_shutdown_temperature);
    telecommand::deserialize(reader, uhf_enable_temperature);
    telecommand::deserialize(reader, sband_shutdown_temperature);
    telecommand::deserialize(reader, sband_enable_temperature);
    telecommand::deserialize(reader, pcb_shutdown_temperature);
    telecommand::deserialize(reader, pcb_enable_temperature);
    telecommand::deserialize(reader, min_valid_temperature);
    telecommand::deserialize(reader, max_valid_temperature);
  }
};
 
template <>
class telecommand::parser<telecommand::packet_id::FPGA_SET_BOOT_MODE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::FPGA_SET_BOOT_MODE> tlc;
    tlc.deserialize(bit_stream);
    auto &fpga = lib::board::get_instance().fpga();
    fpga.set_boot_mode(tlc.m_boot_mode);
    auto &s = settings::get_instance();
    s.set<settings::param::FPGA_BOOT_MODE>(tlc.m_boot_mode);
    return true;
  }
 
private:
  lib::fpga::boot_mode m_boot_mode;
  parser() : m_boot_mode(lib::fpga::boot_mode::QSPI) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    m_boot_mode =
        static_cast<lib::fpga::boot_mode>(reader.read<uint8_t>(2).value());
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::OTA_REQUEST>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::OTA_REQUEST> req;
    req.deserialize(bit_stream);
 
    ota::response_tlm resp;
    auto             &ota = ota::get_instance();
    ota.start(req.start, resp);
    telemetry::tlm<telemetry::apid::OTA_RESP>(m, resp);
    return true;
  }
 
private:
  ota::start_tlc start;
  parser() = default;
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    start.dst = static_cast<ota::subsys>(reader.read<uint8_t>(8).value());
    for (uint8_t i = 0; i < 32; i++) {
      start.sha256[i] = reader.read<uint8_t>(8).value();
    }
    start.size = reader.read<uint32_t>(32).value();
    start.slot = reader.read<uint8_t>(8).value();
    telecommand::prefixed_string path;
    path.deserialize(reader);
    start.name.append(path.value.cbegin(),
                      path.value.cbegin() +
                          std::min(ota::MAX_FILE_LEN, path.length));
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::OTA_DATA>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::OTA_DATA> req;
    req.deserialize(bit_stream);
    ota::response_tlm resp;
    auto             &ota = ota::get_instance();
    ota.recv(req.data, resp);
    telemetry::tlm<telemetry::apid::OTA_RESP>(m, resp);
    return true;
  }
 
private:
  ota::data_tlc data;
  parser() = default;
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    data.session = reader.read<uint8_t>(8).value();
    data.seq     = reader.read<uint32_t>(32).value();
    data.len     = reader.read<uint32_t>(32).value();
    /* Buffer starts after the CCSDS header and the previous fields */
    data.data = reinterpret_cast<const uint8_t *>(
        reader.cbegin() + telecommand::ccsds_tc_header::size + 9);
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::OTA_FINISH>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream, int wdgid)
  {
    parser<telecommand::packet_id::OTA_FINISH> req;
    req.deserialize(bit_stream);
    ota::response_tlm resp;
    auto             &ota = ota::get_instance();
    ota.finalize(req.fin, resp, wdgid);
    telemetry::tlm<telemetry::apid::OTA_RESP>(m, resp);
    return true;
  }
 
private:
  ota::fin_tlc fin;
  parser() = default;
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    fin.session    = reader.read<uint8_t>(8).value();
    fin.method     = reader.read<uint8_t>(8).value();
    fin.delay_secs = reader.read<uint32_t>(32).value();
  }
};
 
template <>
class telecommand::parser<telecommand::packet_id::SET_RADIO_DUTY_CYCLE>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_RADIO_DUTY_CYCLE> req;
    req.deserialize(bit_stream);
 
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_RX_ON_SECS>(req.on_secs);
      s.set<settings::param::UHF_RX_OFF_SECS>(req.off_secs);
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_RX_ON_SECS>(req.on_secs);
      s.set<settings::param::SBAND_RX_OFF_SECS>(req.off_secs);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  uint32_t              on_secs;
  uint32_t              off_secs;
  parser() : iface(lib::radio::interface::UHF) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    on_secs  = reader.read<uint32_t>(32).value();
    off_secs = reader.read<uint32_t>(32).value();
  }
};
 
template <> class telecommand::parser<telecommand::packet_id::SET_TX_WAIT_MS>
{
public:
  static bool
  exec(msg_arbiter::msg &m, etl::bit_stream_reader &bit_stream)
  {
    parser<telecommand::packet_id::SET_TX_WAIT_MS> req;
    req.deserialize(bit_stream);
 
    auto &s = settings::get_instance();
    switch (req.iface) {
    case lib::radio::interface::UHF:
      s.set<settings::param::UHF_TX_WAIT_MS>(req.time_ms);
      break;
    case lib::radio::interface::SBAND:
      s.set<settings::param::SBAND_TX_WAIT_MS>(req.time_ms);
      break;
    default:
      return false;
    }
    return true;
  }
 
private:
  lib::radio::interface iface;
  uint32_t              time_ms;
  parser() : iface(lib::radio::interface::UHF) {}
 
  void
  deserialize(etl::bit_stream_reader &reader)
  {
    iface = static_cast<lib::radio::interface>(reader.read<uint8_t>(1).value());
    time_ms = reader.read<uint32_t>(32).value();
  }
};

bool
telecommand::decode_ccsds_xtce(msg_arbiter::msg       &resp,
                               const msg_arbiter::msg &req, int wdgid)
{
  etl::bit_stream_reader       bit_stream(etl::span(req.data, req.len),
                                          etl::endian::big);
  telecommand::ccsds_tc_header tc_header;
  tc_header.deserialize(bit_stream);
  m_frame_count++;
  bool res = false;
 
  switch (static_cast<packet_id>(tc_header.packet_id_type)) {
  case packet_id::PING: {
    telemetry::tlm<telemetry::apid::PING_RESP>(
        resp, req.data + telecommand::ccsds_tc_header::size,
        req.len - telemetry::ccsds_tm_header::size);
    return true;
  }
  case packet_id::TELEMETRY_REQ: {
    return parse_tlm_req(resp, bit_stream);
  }
  case packet_id::OTA_REQUEST: {
    return parser<packet_id::OTA_REQUEST>::exec(resp, bit_stream);
  }
  case packet_id::OTA_FINISH: {
    return parser<packet_id::OTA_FINISH>::exec(resp, bit_stream, wdgid);
  }
  case packet_id::OTA_DATA: {
    return parser<packet_id::OTA_DATA>::exec(resp, bit_stream);
  }
  case packet_id::TEST_TX_SIMPLE: {
    res =
        parser<telecommand::packet_id::TEST_TX_SIMPLE>::exec(resp, bit_stream);
    break;
  }
  case packet_id::TESTS_STOP: {
    res = parser<telecommand::packet_id::TESTS_STOP>::exec(resp, bit_stream);
    break;
  }
  case packet_id::FPGA_ENABLE: {
    res = parser<telecommand::packet_id::FPGA_ENABLE>::exec(resp, bit_stream);
    break;
  }
  case packet_id::STORAGE_ENABLE: {
    res =
        parser<telecommand::packet_id::STORAGE_ENABLE>::exec(resp, bit_stream);
    break;
  }
  case packet_id::STORAGE_DIRECTION: {
    res = parser<telecommand::packet_id::STORAGE_DIRECTION>::exec(resp,
                                                                  bit_stream);
    break;
  }
  case packet_id::STOP_WDT_UPDATE: {
    res =
        parser<telecommand::packet_id::STOP_WDT_UPDATE>::exec(resp, bit_stream);
    break;
  }
  case packet_id::FREQ_SET: {
    res = parser<telecommand::packet_id::FREQ_SET>::exec(resp, bit_stream);
    break;
  }
  case packet_id::TX_INHIBIT: {
    res = parser<telecommand::packet_id::TX_INHIBIT>::exec(resp, bit_stream);
    break;
  }
  case packet_id::TX_GAIN: {
    res = parser<telecommand::packet_id::TX_GAIN>::exec(resp, bit_stream);
    break;
  }
  case packet_id::IO_WDT_PERIOD: {
    res = parser<telecommand::packet_id::IO_WDT_PERIOD>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_RX_GAIN_MODE: {
    res = parser<telecommand::packet_id::SET_RX_GAIN_MODE>::exec(resp,
                                                                 bit_stream);
    break;
  }
  case packet_id::EMMC_TEST: {
    res = parser<telecommand::packet_id::EMMC_TEST>::exec(resp, bit_stream);
    break;
  }
  case packet_id::RESET_RADIO_STATS: {
    res = parser<telecommand::packet_id::RESET_RADIO_STATS>::exec(resp,
                                                                  bit_stream);
    break;
  }
  case packet_id::SET_RFFE_PARAMS: {
    res =
        parser<telecommand::packet_id::SET_RFFE_PARAMS>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_RTC: {
    res = parser<telecommand::packet_id::SET_RTC>::exec(resp, bit_stream);
    break;
  }
  case packet_id::REBOOT: {
    res = parser<telecommand::packet_id::REBOOT>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_PLL_CLK_SRC: {
    res =
        parser<telecommand::packet_id::SET_PLL_CLK_SRC>::exec(resp, bit_stream);
    break;
  }
  case packet_id::RESET_SETTINGS: {
    res =
        parser<telecommand::packet_id::RESET_SETTINGS>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_FILTER: {
    res = parser<telecommand::packet_id::SET_FILTER>::exec(resp, bit_stream);
    break;
  }
  case packet_id::STORAGE_RM: {
    res = parser<telecommand::packet_id::STORAGE_RM>::exec(resp, bit_stream);
    break;
  }
  case packet_id::STORAGE_RMDIR: {
    res = parser<telecommand::packet_id::STORAGE_RMDIR>::exec(resp, bit_stream);
    break;
  }
  case packet_id::STORAGE_MKDIR: {
    res = parser<telecommand::packet_id::STORAGE_MKDIR>::exec(resp, bit_stream);
    break;
  }
  case packet_id::STORAGE_WRITE: {
    res = parser<telecommand::packet_id::STORAGE_WRITE>::exec(resp, bit_stream);
    break;
  }
  case packet_id::STORAGE_WRITE_OFFSET: {
    res = parser<telecommand::packet_id::STORAGE_WRITE_OFFSET>::exec(
        resp, bit_stream);
    break;
  }
  case packet_id::STORAGE_READ: {
    return parse_storage_tlm(resp, bit_stream,
                             telecommand::packet_id::STORAGE_READ);
  }
  case packet_id::STORAGE_LS: {
    return parse_storage_tlm(resp, bit_stream,
                             telecommand::packet_id::STORAGE_LS);
  }
  case packet_id::STORAGE_FSTATS: {
    return parse_storage_tlm(resp, bit_stream,
                             telecommand::packet_id::STORAGE_FSTATS);
  }
  case packet_id::RING_BUFFER_LOGS: {
    return parse_ring_buffer_logs(resp, bit_stream);
  }
  case packet_id::SAVE_SETTINGS: {
    res = parser<telecommand::packet_id::SAVE_SETTINGS>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_AGC0_CONF: {
    res = parser<telecommand::packet_id::SET_AGC0_CONF>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_AGC1_CONF: {
    res = parser<telecommand::packet_id::SET_AGC1_CONF>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_GAIN0_CONF: {
    res =
        parser<telecommand::packet_id::SET_GAIN0_CONF>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_GAIN1_CONF: {
    res =
        parser<telecommand::packet_id::SET_GAIN1_CONF>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_MODULATION: {
    res =
        parser<telecommand::packet_id::SET_MODULATION>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_TX_FSK_CONF: {
    res =
        parser<telecommand::packet_id::SET_TX_FSK_CONF>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_RX_FSK_CONF: {
    res =
        parser<telecommand::packet_id::SET_RX_FSK_CONF>::exec(resp, bit_stream);
    break;
  }
  case packet_id::DISK_RAW_WRITE: {
    res =
        parser<telecommand::packet_id::DISK_RAW_WRITE>::exec(resp, bit_stream);
    break;
  }
  case packet_id::DISK_RAW_READ: {
    res = parser<telecommand::packet_id::DISK_RAW_READ>::exec(resp, bit_stream);
    return res;
  }
  case packet_id::DISK_SECTORS_ERASE: {
    res = parser<telecommand::packet_id::DISK_SECTORS_ERASE>::exec(resp,
                                                                   bit_stream);
    break;
  }
  case packet_id::SET_RADIO_ENABLE: {
    res = parser<telecommand::packet_id::SET_RADIO_ENABLE>::exec(resp,
                                                                 bit_stream);
    break;
  }
  case packet_id::SET_THERMAL_MONITOR_PARAMS: {
    res = parser<telecommand::packet_id::SET_THERMAL_MONITOR_PARAMS>::exec(
        resp, bit_stream);
    break;
  }
  case packet_id::SET_TX_GS_TURNAROUND_TIME: {
    res = parser<telecommand::packet_id::SET_TX_GS_TURNAROUND_TIME>::exec(
        resp, bit_stream);
    break;
  }
  case packet_id::FPGA_SET_BOOT_MODE: {
    res = parser<telecommand::packet_id::FPGA_SET_BOOT_MODE>::exec(resp,
                                                                   bit_stream);
    break;
  }
  case packet_id::SET_FLASH_MONITOR_DELAY_SEC: {
    res = parser<telecommand::packet_id::SET_FLASH_MONITOR_DELAY_SEC>::exec(
        resp, bit_stream);
    break;
  }
  case packet_id::RESET_ALL_OTA_SESSIONS: {
    res = parser<telecommand::packet_id::RESET_ALL_OTA_SESSIONS>::exec(
        resp, bit_stream);
    break;
  }
  case packet_id::RESET_OTA_SESSION: {
    res = parser<telecommand::packet_id::RESET_OTA_SESSION>::exec(resp,
                                                                  bit_stream);
    break;
  }
  case packet_id::CONFIRM_IMAGE: {
    res = parser<telecommand::packet_id::CONFIRM_IMAGE>::exec(resp, bit_stream);
    break;
  }
  case packet_id::SET_RADIO_DUTY_CYCLE: {
    res = parser<telecommand::packet_id::SET_RADIO_DUTY_CYCLE>::exec(
        resp, bit_stream);
    break;
  }
  case packet_id::SET_TX_WAIT_MS: {
    res =
        parser<telecommand::packet_id::SET_TX_WAIT_MS>::exec(resp, bit_stream);
    break;
  }
  /*
   * If no match, either the TC was completely invalid, or it might be a mission
   * specific. In both cases, the handling stops here without any other action
   */
  default:
    return false;
  }
  telemetry::tlm<telemetry::apid::CMD_ACK>(resp, res);
  return res;
}
 
} // namespace satnogs::comms