telemetry.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 "bsp/bsp.hpp"
#include "callbacks.hpp"
#include "error_handler.hpp"
#include "etl/map.h"
#include "io.hpp"
#include "msg_arbiter.hpp"
#include "ota.hpp"
#include "settings.hpp"
#include "storage.hpp"
#include "telecommand.hpp"
#include "thermal.hpp"
#include "time.hpp"
#include <etl/algorithm.h>
#include <etl/basic_string.h>
#include <etl/bit_stream.h>
#include <etl/string.h>
#include <satnogs-comms-lib/power.hpp>
#include <satnogs-comms-lib/radio.hpp>
#include <satnogs-comms-lib/version.hpp>
#include <version.hpp>
#include <zephyr/dfu/mcuboot.h>
#include <zephyr/kernel.h>
#include <zephyr/retention/blinfo.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/task_wdt/task_wdt.h>
 
#if CONFIG_BOOTLOADER_MCUBOOT
#include <bootutil/boot_status.h>
#include <bootutil/image.h>
#endif
 
namespace scl = satnogs::comms::lib;
namespace satnogs::comms
{
 
class telemetry
{
public:
  enum class apid : uint16_t
  {
    PING_RESP             = 100,
    CMD_ACK               = 101,
    BASIC                 = 102,
    POWER                 = 103,
    HEALTH                = 104,
    CONFIG                = 105,
    FPGA                  = 106,
    RADIO                 = 107,
    TIME                  = 108,
    STORAGE_STATUS        = 109,
    BOOTLOADER_INFO       = 110,
    STORAGE_LS_RESP       = 111,
    STORAGE_READ_RESP     = 112,
    STORAGE_FSTATS_RESP   = 113,
    SETTINGS              = 114,
    RING_BUFFER_LOGS_RESP = 115,
    DISK_RAW_READ_RESP    = 116,
    OTA_RESP              = 117,
    OTA_SESSION_INFO      = 118
  };
 
  /* Primary traits template for all the telemetry types defined by a specific
   * APID */
  template <apid A> class serializer;
 
  class sensors
  {
  public:
    static void
    serialize(etl::bit_stream_writer &writer)
    {
      auto &board = scl::board::get_instance();
      telemetry::serialize(writer,
                           board.temperature(scl::temperature_sensor::PCB));
      telemetry::serialize(writer,
                           board.temperature(scl::temperature_sensor::UHF_PA));
      telemetry::serialize(
          writer, board.temperature(scl::temperature_sensor::SBAND_PA));
      writer.write<bool>(board.alert(scl::temperature_sensor::UHF_PA), 1);
      writer.write<bool>(board.alert(scl::temperature_sensor::SBAND_PA), 1);
    }
  };
 
  class gnss
  {
  public:
    static void
    serialize(etl::bit_stream_writer &writer)
    {
      auto            &time = satnogs::comms::time::get_instance();
      struct gnss_data data;
      time.gnss(data);
      writer.write<uint32_t>(data.info.satellites_cnt, 32);
      writer.write<uint32_t>(data.info.hdop, 32);
      writer.write<uint8_t>(data.info.fix_status, 8);
      writer.write<uint8_t>(data.info.fix_quality, 8);
      writer.write<uint32_t>(data.utc.hour, 32);
      writer.write<uint32_t>(data.utc.minute, 32);
      writer.write<uint32_t>(data.utc.millisecond, 32);
      writer.write<uint32_t>(data.utc.month_day, 32);
      writer.write<uint32_t>(data.utc.month, 32);
      writer.write<uint32_t>(data.utc.century_year, 32);
      telemetry::serialize(writer, data.nav_data.latitude * 1e-9f);
      telemetry::serialize(writer, data.nav_data.longitude * 1e-9f);
      telemetry::serialize(writer, data.nav_data.bearing * 1e-3f);
      telemetry::serialize(writer, data.nav_data.speed * 1e-3f);
      telemetry::serialize(writer, data.nav_data.altitude * 1e-3f);
 
      writer.write<uint64_t>(time.last_gnss_update_uptime(), 64);
      writer.write<uint64_t>(time.last_nmea_update_uptime(), 64);
    }
  };
 
  class power
  {
  public:
    static void
    serialize(etl::bit_stream_writer &writer)
    {
      const auto &pwr = scl::board::get_instance().power();
      // Serialize power_enable
      writer.write<bool>(pwr.enabled(scl::power::subsys::RF_5V), 1);
      writer.write<bool>(pwr.enabled(scl::power::subsys::FPGA_5V), 1);
      writer.write<bool>(pwr.enabled(scl::power::subsys::CAN1), 1);
      writer.write<bool>(pwr.enabled(scl::power::subsys::CAN1_LPWR), 1);
      writer.write<bool>(pwr.enabled(scl::power::subsys::CAN2), 1);
      writer.write<bool>(pwr.enabled(scl::power::subsys::CAN2_LPWR), 1);
      writer.write<bool>(pwr.enabled(scl::power::subsys::UHF), 1);
      writer.write<bool>(pwr.enabled(scl::power::subsys::SBAND), 1);
 
      telemetry::serialize(writer, pwr.voltage(scl::power::channel::VIN));
      telemetry::serialize(writer, pwr.current(scl::power::channel::VIN));
      telemetry::serialize(writer, pwr.current(scl::power::channel::FPGA));
      telemetry::serialize(writer, pwr.current(scl::power::channel::DIG_3V3));
      telemetry::serialize(writer, pwr.current(scl::power::channel::RF_5V));
      telemetry::serialize(writer, pwr.get_power(scl::power::sensor::EMC1702));
      telemetry::serialize(writer, pwr.get_power(scl::power::sensor::EFUSES));
      telemetry::serialize(writer, pwr.voltage(scl::power::channel::V_BAT));
 
      writer.write<bool>(pwr.pgood(scl::power::pgood_tp::RAIL_5V), 1);
      writer.write<bool>(pwr.pgood(scl::power::pgood_tp::RAIL_FPGA), 1);
      writer.write<bool>(pwr.pgood(scl::power::pgood_tp::RAIL_UHF), 1);
      writer.write<bool>(pwr.pgood(scl::power::pgood_tp::RAIL_SBAND), 1);
    }
  };
 
  class uhf_radio
  {
  public:
    static void
    serialize(etl::bit_stream_writer &writer)
    {
      using scr = scl::radio;
 
      auto       &b     = scl::board::get_instance();
      auto       &radio = b.radio();
      const auto &iface = io::get_instance().radio_ctrl().uhf();
 
      writer.write(radio.enabled(scr::interface::UHF), 1);
      writer.write(static_cast<bool>(radio.direction(scr::interface::UHF)), 1);
      writer.write(static_cast<uint8_t>(iface.get_state()), 2);
      writer.write(static_cast<uint8_t>(radio.uhf().get_filter()), 1);
 
      writer.write<uint32_t>(
          static_cast<uint32_t>(
              radio.frequency(scr::interface::UHF, scl::rf_frontend::dir::TX)),
          32);
      writer.write<uint32_t>(
          static_cast<uint32_t>(
              radio.frequency(scr::interface::UHF, scl::rf_frontend::dir::RX)),
          32);
      const auto &stats = iface.get_stats();
      writer.write(stats.tx_frames, 32);
      writer.write(stats.tx_frames_fail, 32);
      writer.write(stats.tx_frames_drop, 32);
      writer.write(stats.rx_frames, 32);
      writer.write(stats.rx_frames_inval, 32);
      writer.write(stats.rx_frames_drop, 32);
      writer.write<uint64_t>(stats.last_rx_ts, 64);
      telemetry::serialize(writer, stats.last_rssi);
      writer.write<uint64_t>(stats.last_valid_rx_ts, 64);
      telemetry::serialize(writer, stats.last_valid_rssi);
    }
  };
 
  class sband_radio
  {
  public:
    static void
    serialize(etl::bit_stream_writer &writer)
    {
      using scr = scl::radio;
 
      auto       &b     = scl::board::get_instance();
      auto       &radio = b.radio();
      const auto &iface = io::get_instance().radio_ctrl().sband();
 
      writer.write(radio.enabled(scr::interface::SBAND), 1);
      writer.write(static_cast<bool>(radio.direction(scr::interface::SBAND)),
                   1);
      writer.write(static_cast<uint8_t>(iface.get_state()), 2);
      writer.write(radio.sband().mixer_lock(), 1);
      writer.write(static_cast<uint8_t>(radio.sband().get_filter()), 1);
 
      writer.write<uint32_t>(
          static_cast<uint32_t>(radio.frequency(scr::interface::SBAND,
                                                scl::rf_frontend::dir::TX)),
          32);
      writer.write<uint32_t>(
          static_cast<uint32_t>(radio.frequency(scr::interface::SBAND,
                                                scl::rf_frontend::dir::RX)),
          32);
 
      const auto &stats = iface.get_stats();
      writer.write(stats.tx_frames, 32);
      writer.write(stats.tx_frames_fail, 32);
      writer.write(stats.tx_frames_drop, 32);
      writer.write(stats.rx_frames, 32);
      writer.write(stats.rx_frames_inval, 32);
      writer.write(stats.rx_frames_drop, 32);
      writer.write<uint64_t>(stats.last_rx_ts, 64);
      telemetry::serialize(writer, stats.last_rssi);
      writer.write<uint64_t>(stats.last_valid_rx_ts, 64);
      telemetry::serialize(writer, stats.last_valid_rssi);
    }
  };
 
  class ccsds_tm_header
  {
  public:
    static constexpr size_t size = 6U;
    uint8_t                 version;
    uint8_t                 type;
    uint8_t                 sec_hdr;
    uint16_t                apid;
    uint8_t                 group_flags;
    uint16_t                count;
    uint16_t                length;
 
    ccsds_tm_header()
        : version(0),
          type(0),
          sec_hdr(0),
          apid(0),
          group_flags(0b11),
          count(0),
          length(0)
    {
    }
 
    void
    serialize(etl::bit_stream_writer &writer) const
    {
      writer.write<uint8_t>(version, 3);
      writer.write<uint8_t>(type, 1);
      writer.write<uint8_t>(sec_hdr, 1);
      writer.write<uint16_t>(apid, 11);
      writer.write<uint8_t>(group_flags, 2);
      writer.write<uint16_t>(count, 14);
      writer.write<uint16_t>(length, 16);
    }
  };
 
  static telemetry &
  get_instance()
  {
    static telemetry tlm;
    return tlm;
  }
 
  /* Singleton */
  telemetry(telemetry const &) = delete;
 
  void
  operator=(telemetry const &) = delete;
 
  static void
  serialize(etl::bit_stream_writer &writer, float x);
 
  static void
  serialize(etl::bit_stream_writer &writer, double x);
 
  template <telemetry::apid Apid, typename... Args>
  static void
  tlm(msg_arbiter::msg &m, Args &&...args)
  {
    telemetry::ccsds_tm_header tm_header;
    auto                      &tlc = telecommand::get_instance();
    tm_header.apid                 = static_cast<uint16_t>(Apid);
    tm_header.count                = tlc.get_frame_count();
 
    etl::bit_stream_writer bit_stream_hdr(
        m.data, telemetry::ccsds_tm_header::size, etl::endian::big);
    etl::bit_stream_writer bit_stream_pld(
        m.data + telemetry::ccsds_tm_header::size,
        msg_arbiter::mtu - telemetry::ccsds_tm_header::size, etl::endian::big);
 
    serializer<Apid>::serialize(bit_stream_pld, std::forward<Args>(args)...);
 
    tm_header.length = bit_stream_pld.size_bytes() + 1;
    tm_header.serialize(bit_stream_hdr);
    m.len = telemetry::ccsds_tm_header::size + tm_header.length;
  }
 
  static void
  send_ring_buffer_logs_tlm(msg_arbiter::msg &m, const size_t num_of_logs);
 
  static void
  send_all_ota_sessions_info_tlm(msg_arbiter::msg &m);
 
private:
  telemetry();
};
 
template <> class telemetry::serializer<telemetry::apid::PING_RESP>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer, uint8_t const buf[], size_t len)
  {
    for (size_t i = 0; i < len; ++i) {
      writer.write<uint8_t>(buf[i], 8);
    }
  }
};
 
template <> class telemetry::serializer<telemetry::apid::CMD_ACK>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer, bool success)
  {
    writer.write<bool>(success, 1);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::BASIC>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer)
  {
    auto &s = settings::get_instance();
    writer.write<uint64_t>(k_uptime_get(), 64);
    writer.write<uint32_t>(s.get<settings::param::BOOT_COUNT>(), 32);
    // Serialize uhf_radio
    telemetry::uhf_radio::serialize(writer);
    // Serialize sband_radio
    telemetry::sband_radio::serialize(writer);
    // Serialize power
    telemetry::power::serialize(writer);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::POWER>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer)
  {
    telemetry::power::serialize(writer);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::HEALTH>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer)
  {
    auto &s             = settings::get_instance();
    auto  thermal_state = thermal::get_instance().get_state();
    writer.write<uint64_t>(k_uptime_get(), 64);
    writer.write<uint32_t>(s.get<settings::param::BOOT_COUNT>(), 32);
    // Serialize sensors
    telemetry::sensors::serialize(writer);
    // Serialize rst_cause
    writer.write<uint16_t>(error_handler::get_instance().hwinfo_reset_cause(),
                           15);
    // Serialize power
    telemetry::power::serialize(writer);
    // Serialize thermal state
    writer.write<bool>(thermal_state.uhf_triggered, 1);
    writer.write<bool>(thermal_state.sband_triggered, 1);
    writer.write<bool>(thermal_state.uhf_sensor_valid, 1);
    writer.write<bool>(thermal_state.sband_sensor_valid, 1);
    writer.write<bool>(thermal_state.pcb_sensor_valid, 1);
    // Add padding
    writer.skip(6);
    // Serialize latest exception message
    auto &log              = logger::get_instance();
    auto  retained_mem_str = log.get_latest_exception();
    for (size_t i = 0; i < retained_mem_str.size(); ++i) {
      writer.write<uint8_t>(static_cast<uint8_t>(retained_mem_str[i]), 8);
    }
    // Append the null termination byte for proper render at the MCS
    writer.write<uint8_t>(0x0, 8);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::CONFIG>
{
public:
  static constexpr size_t hash_max_len = 256 / 8;
 
  static void
  append_git_hash(etl::bit_stream_writer &writer, const char *hash)
  {
    size_t hash_len = strnlen(hash, hash_max_len);
    for (size_t i = 0; i < hash_len; i++) {
      writer.write<uint8_t>(hash[i], 8);
    }
    for (size_t i = hash_len; i < hash_max_len; i++) {
      writer.write<uint8_t>(0x0, 8);
    }
  }
 
  static void
  serialize(etl::bit_stream_writer &writer)
  {
    auto &s = settings::get_instance();
    /* harware version */
    writer.write<uint32_t>(scl::version::hw_major, 32);
    writer.write<uint32_t>(scl::version::hw_minor, 32);
    writer.write<uint32_t>(scl::version::hw_patch, 32);
 
    /* libsatnogs-comms version */
    writer.write<uint32_t>(scl::version::lib_major, 32);
    writer.write<uint32_t>(scl::version::lib_minor, 32);
    writer.write<uint32_t>(scl::version::lib_patch, 32);
    append_git_hash(writer, scl::version::lib_git_hash);
 
    /* firmware version */
    writer.write<uint32_t>(satnogs::comms::version::fw_major, 32);
    writer.write<uint32_t>(satnogs::comms::version::fw_minor, 32);
    writer.write<uint32_t>(satnogs::comms::version::fw_patch, 32);
    append_git_hash(writer, satnogs::comms::version::fw_git_hash);
 
    writer.write<bool>(!s.get<settings::param::UHF_TX_EN>(), 1);
    writer.write<bool>(!s.get<settings::param::SBAND_TX_EN>(), 1);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::FPGA>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer)
  {
    auto &fpga = scl::board::get_instance().fpga();
    writer.write<bool>(fpga.enabled(), 1);
    writer.write<bool>(fpga.get_fpga_done(), 1);
    // TODO: Add correct methods when implemented in libsatnogs-comms
    writer.write<bool>(false, 1);
    writer.write<bool>(false, 1);
    writer.write<bool>(false, 1);
    writer.write<uint8_t>(static_cast<uint8_t>(fpga.get_boot_mode()), 2);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::RADIO>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer)
  {
    // Serialize uhf_radio
    telemetry::uhf_radio::serialize(writer);
    // Serialize sband_radio
    telemetry::sband_radio::serialize(writer);
    // Serialize PLL clock source
    writer.write<uint8_t>(
        static_cast<uint8_t>(scl::board::get_instance().radio().get_clk_src()),
        1);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::TIME>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer)
  {
    auto &time = satnogs::comms::time::get_instance();
    /* Uptime */
    writer.write<uint64_t>(time.uptime(), 64);
    uint64_t t;
    writer.write<uint8_t>(static_cast<uint8_t>(time.get(t)), 8);
    writer.write<uint64_t>(t, 64);
    telemetry::gnss::serialize(writer);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::STORAGE_STATUS>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer)
  {
    auto &s = storage::get_instance();
    writer.write<bool>(s.enabled(), 1);
    writer.write<bool>(s.mounted(), 1);
    writer.write<bool>(static_cast<bool>(s.get_dir()), 1);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::BOOTLOADER_INFO>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer)
  {
#if CONFIG_BOOTLOADER_MCUBOOT
    char v = 0;
    blinfo_lookup(BLINFO_MODE, &v, sizeof(v));
    writer.write<uint8_t>(v, 8);
    v = 0;
    blinfo_lookup(BLINFO_SIGNATURE_TYPE, &v, sizeof(v));
    writer.write<uint8_t>(v, 8);
    v = 0;
    blinfo_lookup(BLINFO_RECOVERY, &v, sizeof(v));
    writer.write<uint8_t>(v, 8);
    blinfo_lookup(BLINFO_RUNNING_SLOT, &v, sizeof(v));
    writer.write<uint8_t>(v, 8);
 
    struct image_version mcuboot_version;
    blinfo_lookup(BLINFO_BOOTLOADER_VERSION,
                  reinterpret_cast<char *>(&mcuboot_version),
                  sizeof(mcuboot_version));
    writer.write<uint32_t>(mcuboot_version.iv_major, 32);
    writer.write<uint32_t>(mcuboot_version.iv_minor, 32);
    writer.write<uint32_t>(mcuboot_version.iv_revision, 32);
 
    uint32_t s = 0;
    blinfo_lookup(BLINFO_MAX_APPLICATION_SIZE, reinterpret_cast<char *>(&s),
                  sizeof(s));
    writer.write<uint32_t>(s, 32);
    writer.write<bool>(boot_is_img_confirmed(), 1);
 
    /* Have a look at ota class for this one */
    uint8_t areas[2] = {FIXED_PARTITION_ID(slot0_partition),
                        FIXED_PARTITION_ID(slot1_partition)};
    /* Get the fimrware information for the two available slots */
    for (uint8_t i = 0; i < 2; i++) {
      struct mcuboot_img_header mcuboot_hdr;
      memset(&mcuboot_hdr, 0, sizeof(mcuboot_hdr));
      boot_read_bank_header(areas[i], &mcuboot_hdr, sizeof(mcuboot_hdr));
      writer.write<uint32_t>(mcuboot_hdr.h.v1.image_size, 32);
      writer.write<uint32_t>(mcuboot_hdr.h.v1.sem_ver.major, 32);
      writer.write<uint32_t>(mcuboot_hdr.h.v1.sem_ver.minor, 32);
      writer.write<uint32_t>(mcuboot_hdr.h.v1.sem_ver.revision, 32);
    }
#endif
  }
};
 
template <> class telemetry::serializer<telemetry::apid::STORAGE_LS_RESP>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer, etl::istring &path)
  {
    auto           &storage = storage::get_instance();
    etl::string_ext res(reinterpret_cast<char *>(writer.begin()),
                        writer.capacity_bytes());
    storage.ls(path, res);
    writer.skip(res.length() * 8 + 8);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::STORAGE_READ_RESP>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer, etl::istring &path, size_t offset,
            size_t len)
  {
    auto  &storage = storage::get_instance();
    size_t bytes   = storage.read(
        path, (uint8_t *)(writer.begin() + sizeof(uint32_t)), len, offset);
    writer.write<uint32_t>(bytes, 32);
    writer.skip(8 * bytes);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::STORAGE_FSTATS_RESP>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer, etl::istring &path)
  {
    auto    &storage = storage::get_instance();
    uint32_t ret     = storage.du(path);
    memcpy(writer.begin(), path.c_str(), path.size());
    writer.skip(8 * path.size());
    writer.write<char>('\0', 8);
    writer.write<uint32_t>(ret, 32);
    writer.write(static_cast<bool>(storage.is_dir(path)), 1);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::SETTINGS>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer)
  {
    auto &s = settings::get_instance();
    /* Boot count */
    writer.write<uint32_t>(s.get<settings::param::BOOT_COUNT>(), 32);
 
    /* WDT period setting */
    writer.write<uint32_t>(s.get<settings::param::IO_WDG_PERIOD_MINS>(), 32);
 
    /* PLL reference clock setting */
    writer.write<uint8_t>(s.get<settings::param::PLL_REF_CLK_SRC>(), 1);
 
    /* UHF radio settings */
    writer.write<uint32_t>(s.get<settings::param::UHF_TX_FREQ>(), 32);
    writer.write<uint32_t>(s.get<settings::param::UHF_RX_FREQ>(), 32);
    writer.write<bool>(s.get<settings::param::UHF_TX_EN>(), 1);
    telemetry::serialize(writer, s.get<settings::param::UHF_TX_GAIN>());
    writer.write<uint32_t>(s.get<settings::param::UHF_RX_RANGE_MIN>(), 32);
    writer.write<uint32_t>(s.get<settings::param::UHF_RX_RANGE_MAX>(), 32);
    writer.write<uint32_t>(s.get<settings::param::UHF_TX_RANGE_MIN>(), 32);
    writer.write<uint32_t>(s.get<settings::param::UHF_TX_RANGE_MAX>(), 32);
    telemetry::serialize(writer, s.get<settings::param::UHF_AGC0_RANGE_MIN>());
    telemetry::serialize(writer, s.get<settings::param::UHF_AGC0_RANGE_MAX>());
    telemetry::serialize(writer, s.get<settings::param::UHF_GAIN0_RANGE_MIN>());
    telemetry::serialize(writer, s.get<settings::param::UHF_GAIN0_RANGE_MAX>());
    telemetry::serialize(writer,
                         s.get<settings::param::UHF_AGC0_CALIB_SLOPE>());
    telemetry::serialize(writer,
                         s.get<settings::param::UHF_AGC0_CALIB_INTRCPT>());
    telemetry::serialize(writer,
                         s.get<settings::param::UHF_GAIN0_CALIB_SLOPE>());
    telemetry::serialize(writer,
                         s.get<settings::param::UHF_GAIN0_CALIB_INTRCPT>());
    writer.write<uint8_t>(
        static_cast<uint8_t>(s.get<settings::param::UHF_FILTER>()), 1);
 
    writer.write<uint8_t>(
        static_cast<uint8_t>(s.get<settings::param::UHF_GAIN0_MODE>()), 1);
    writer.write<uint8_t>(
        static_cast<uint8_t>(s.get<settings::param::UHF_GAIN1_MODE>()), 1);
 
    telemetry::serialize(writer, s.get<settings::param::UHF_GAIN0_TGT>());
    telemetry::serialize(writer, s.get<settings::param::UHF_GAIN0_GAIN>());
    auto agc1 = s.get<settings::param::UHF_GAIN1_AGC>();
    writer.write<uint8_t>(agc1.avg, 2);
    writer.write<uint8_t>(agc1.input, 1);
    writer.write<uint8_t>(agc1.tgt, 3);
    telemetry::serialize(writer, s.get<settings::param::UHF_GAIN1_GAIN>());
 
    writer.write<uint8_t>(
        static_cast<uint8_t>(s.get<settings::param::UHF_TX_MODULATION>()), 3);
    writer.write<uint8_t>(
        static_cast<uint8_t>(s.get<settings::param::UHF_RX_MODULATION>()), 3);
 
    auto fsk = s.get<settings::param::UHF_FSK_TX>();
    writer.write<uint8_t>(fsk.baudrate, 3);
    telemetry::serialize(writer, fsk.mod_idx);
    telemetry::serialize(writer, fsk.shaping);
    fsk = s.get<settings::param::UHF_FSK_RX>();
    writer.write<uint8_t>(fsk.baudrate, 3);
    telemetry::serialize(writer, fsk.mod_idx);
    writer.write<bool>(s.get<settings::param::UHF_ENABLE>(), 1);
    writer.write<uint32_t>(s.get<settings::param::UHF_TRX_TURNAROUND_MS>(), 32);
    writer.write<uint32_t>(s.get<settings::param::UHF_RX_ON_SECS>(), 32);
    writer.write<uint32_t>(s.get<settings::param::UHF_RX_OFF_SECS>(), 32);
    writer.write<uint32_t>(s.get<settings::param::UHF_TX_WAIT_MS>(), 32);
 
    /* S-band radio settings */
    writer.write<uint32_t>(s.get<settings::param::SBAND_TX_FREQ>(), 32);
    writer.write<uint32_t>(s.get<settings::param::SBAND_RX_FREQ>(), 32);
    writer.write<bool>(s.get<settings::param::SBAND_TX_EN>(), 1);
    telemetry::serialize(writer, s.get<settings::param::SBAND_TX_GAIN>());
    writer.write<uint32_t>(s.get<settings::param::SBAND_RX_RANGE_MIN>(), 32);
    writer.write<uint32_t>(s.get<settings::param::SBAND_RX_RANGE_MAX>(), 32);
    writer.write<uint32_t>(s.get<settings::param::SBAND_TX_RANGE_MIN>(), 32);
    writer.write<uint32_t>(s.get<settings::param::SBAND_TX_RANGE_MAX>(), 32);
    telemetry::serialize(writer,
                         s.get<settings::param::SBAND_AGC0_RANGE_MIN>());
    telemetry::serialize(writer,
                         s.get<settings::param::SBAND_AGC0_RANGE_MAX>());
    telemetry::serialize(writer,
                         s.get<settings::param::SBAND_GAIN0_RANGE_MIN>());
    telemetry::serialize(writer,
                         s.get<settings::param::SBAND_GAIN0_RANGE_MAX>());
    telemetry::serialize(writer,
                         s.get<settings::param::SBAND_AGC0_CALIB_SLOPE>());
    telemetry::serialize(writer,
                         s.get<settings::param::SBAND_AGC0_CALIB_INTRCPT>());
    telemetry::serialize(writer,
                         s.get<settings::param::SBAND_GAIN0_CALIB_SLOPE>());
    telemetry::serialize(writer,
                         s.get<settings::param::SBAND_GAIN0_CALIB_INTRCPT>());
    writer.write<uint8_t>(
        static_cast<uint8_t>(s.get<settings::param::SBAND_FILTER>()), 1);
 
    writer.write<uint8_t>(
        static_cast<uint8_t>(s.get<settings::param::SBAND_GAIN0_MODE>()), 1);
    writer.write<uint8_t>(
        static_cast<uint8_t>(s.get<settings::param::SBAND_GAIN1_MODE>()), 1);
 
    telemetry::serialize(writer, s.get<settings::param::SBAND_GAIN0_TGT>());
    telemetry::serialize(writer, s.get<settings::param::SBAND_GAIN0_GAIN>());
    agc1 = s.get<settings::param::SBAND_GAIN1_AGC>();
    writer.write<uint8_t>(agc1.avg, 2);
    writer.write<uint8_t>(agc1.input, 1);
    writer.write<uint8_t>(agc1.tgt, 3);
    telemetry::serialize(writer, s.get<settings::param::SBAND_GAIN1_GAIN>());
 
    writer.write<uint8_t>(
        static_cast<uint8_t>(s.get<settings::param::SBAND_TX_MODULATION>()), 3);
    writer.write<uint8_t>(
        static_cast<uint8_t>(s.get<settings::param::SBAND_RX_MODULATION>()), 3);
 
    fsk = s.get<settings::param::SBAND_FSK_TX>();
    writer.write<uint8_t>(fsk.baudrate, 3);
    telemetry::serialize(writer, fsk.mod_idx);
    telemetry::serialize(writer, fsk.shaping);
    fsk = s.get<settings::param::SBAND_FSK_RX>();
    writer.write<uint8_t>(fsk.baudrate, 3);
    telemetry::serialize(writer, fsk.mod_idx);
    writer.write<bool>(s.get<settings::param::SBAND_ENABLE>(), 1);
    writer.write<uint32_t>(s.get<settings::param::SBAND_TRX_TURNAROUND_MS>(),
                           32);
    writer.write<uint32_t>(s.get<settings::param::SBAND_RX_ON_SECS>(), 32);
    writer.write<uint32_t>(s.get<settings::param::SBAND_RX_OFF_SECS>(), 32);
    writer.write<uint32_t>(s.get<settings::param::SBAND_TX_WAIT_MS>(), 32);
 
    // Serializing thermal monitor parameters
    telemetry::serialize(writer,
                         s.get<settings::param::THERMAL_UHF_SHUTDOWN_TEMP>());
    telemetry::serialize(writer,
                         s.get<settings::param::THERMAL_UHF_ENABLE_TEMP>());
    telemetry::serialize(writer,
                         s.get<settings::param::THERMAL_SBAND_SHUTDOWN_TEMP>());
    telemetry::serialize(writer,
                         s.get<settings::param::THERMAL_SBAND_ENABLE_TEMP>());
    telemetry::serialize(writer,
                         s.get<settings::param::THERMAL_PCB_SHUTDOWN_TEMP>());
    telemetry::serialize(writer,
                         s.get<settings::param::THERMAL_PCB_ENABLE_TEMP>());
    telemetry::serialize(writer,
                         s.get<settings::param::THERMAL_MIN_VALID_TEMP>());
    telemetry::serialize(writer,
                         s.get<settings::param::THERMAL_MAX_VALID_TEMP>());
  }
};
 
template <> class telemetry::serializer<telemetry::apid::DISK_RAW_READ_RESP>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer, size_t start_sector, size_t sectors)
  {
    auto &storage = storage::get_instance();
    /* Clamp to the available response size */
    size_t nbytes = sectors * storage::SECTOR_SIZE;
    nbytes        = etl::clamp(nbytes, 0U, writer.available<uint8_t>());
    size_t ret    = storage.read_raw(
        reinterpret_cast<uint8_t *>(writer.end() + sizeof(uint32_t)),
        start_sector, nbytes / storage::SECTOR_SIZE);
    writer.write<uint32_t>(ret * storage::SECTOR_SIZE, 32);
    writer.skip(ret * storage::SECTOR_SIZE * 8);
  }
};
 
template <> class telemetry::serializer<telemetry::apid::OTA_RESP>
{
public:
  static void
  serialize(etl::bit_stream_writer &writer, const ota::response_tlm &resp)
  {
    writer.write<uint8_t>(resp.session, 8);
    writer.write<uint8_t>(static_cast<uint8_t>(resp.s), 8);
    writer.write<uint32_t>(resp.ack, 32);
  }
};
 
} // namespace satnogs::comms