telecommand.hpp

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
 */
 
#pragma once
 
#include "msg_arbiter.hpp"
#include "ota.hpp"
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <etl/bit_stream.h>
 
namespace satnogs::comms
{
class telecommand
{
public:
  static telecommand &
  get_instance()
  {
    static telecommand instance;
    return instance;
  }
 
  enum class packet_id : uint16_t
  {
    PING                        = 1,
    TELEMETRY_REQ               = 2,
    OTA_REQUEST                 = 3,
    OTA_FINISH                  = 4,
    OTA_DATA                    = 5,
    TEST_TX_SIMPLE              = 6,
    TESTS_STOP                  = 7,
    FPGA_ENABLE                 = 8,
    STORAGE_ENABLE              = 9,
    STORAGE_DIRECTION           = 10,
    STOP_WDT_UPDATE             = 11,
    FREQ_SET                    = 12,
    TX_INHIBIT                  = 13,
    TX_GAIN                     = 14,
    IO_WDT_PERIOD               = 15,
    SET_RX_GAIN_MODE            = 16,
    EMMC_TEST                   = 17,
    RESET_RADIO_STATS           = 18,
    SET_RFFE_PARAMS             = 19,
    SET_RTC                     = 20,
    REBOOT                      = 21,
    SET_PLL_CLK_SRC             = 22,
    RESET_SETTINGS              = 23,
    SET_FILTER                  = 24,
    STORAGE_LS                  = 25,
    STORAGE_READ                = 26,
    STORAGE_MKDIR               = 27,
    STORAGE_RMDIR               = 28,
    STORAGE_RM                  = 29,
    STORAGE_WRITE               = 30,
    STORAGE_WRITE_OFFSET        = 31,
    STORAGE_FSTATS              = 32,
    RING_BUFFER_LOGS            = 33,
    SAVE_SETTINGS               = 34,
    SET_AGC0_CONF               = 35,
    SET_AGC1_CONF               = 36,
    SET_GAIN0_CONF              = 37,
    SET_GAIN1_CONF              = 38,
    SET_MODULATION              = 39,
    SET_TX_FSK_CONF             = 40,
    SET_RX_FSK_CONF             = 41,
    DISK_RAW_WRITE              = 42,
    DISK_RAW_READ               = 43,
    DISK_SECTORS_ERASE          = 44,
    SET_RADIO_ENABLE            = 45,
    SET_THERMAL_MONITOR_PARAMS  = 46,
    SET_TX_GS_TURNAROUND_TIME   = 47,
    FPGA_SET_BOOT_MODE          = 48,
    SET_FLASH_MONITOR_DELAY_SEC = 49,
    RESET_ALL_OTA_SESSIONS      = 50,
    RESET_OTA_SESSION           = 51,
    CONFIRM_IMAGE               = 52,
    SET_RADIO_DUTY_CYCLE        = 53,
    SET_TX_WAIT_MS              = 54
  };
 
  /* Primary traits template for all the telecommand types defined by a specific
   * tc_packet_id */
  template <packet_id A> class parser;
 
  enum class storage_direction : bool
  {
    MCU  = 0,
    FPGA = 1
  };
 
  class ccsds_tc_header
  {
  public:
    static constexpr size_t size = 8U;
    uint8_t                 version;
    uint8_t                 type;
    uint8_t                 sec_hdr;
    uint16_t                apid;
    uint8_t                 group_flags;
    uint16_t                count;
    uint16_t                length;
    uint16_t                packet_id_type;
 
    ccsds_tc_header()
        : version(0),
          type(0),
          sec_hdr(0),
          apid(0),
          group_flags(0),
          count(0),
          length(0),
          packet_id_type(0)
    {
    }
 
    void
    deserialize(etl::bit_stream_reader &reader)
    {
      version        = reader.read<uint8_t>(3).value();
      type           = reader.read<uint8_t>(1).value();
      sec_hdr        = reader.read<uint8_t>(1).value();
      apid           = reader.read<uint16_t>(11).value();
      group_flags    = reader.read<uint8_t>(2).value();
      count          = reader.read<uint16_t>(14).value();
      length         = reader.read<uint16_t>(16).value();
      packet_id_type = reader.read<uint16_t>(16).value();
    }
  };
 
  class prefixed_string
  {
  public:
    prefixed_string() = default;
 
    size_t                                   length;
    etl::string<CONFIG_STORAGE_MAX_PATH_LEN> value;
 
    void
    deserialize(etl::bit_stream_reader &reader)
    {
      value.clear();
      length = reader.read<uint32_t>(32).value();
      for (size_t i = 0; i < length; ++i) {
        value.push_back(reader.read<char>(8).value());
      }
    }
  };
 
  /* Singleton */
  telecommand(telecommand const &) = delete;
 
  void
  operator=(telecommand const &) = delete;
 
  bool
  ccsds_frame_valid(const uint8_t *b, size_t len);
 
  int
  get_frame_count();
 
  bool
  decode_ccsds_xtce(msg_arbiter::msg &m, int wdgid);
 
  bool
  decode_ccsds_xtce(msg_arbiter::msg &resp, const msg_arbiter::msg &req,
                    int wdgid);
 
  static void
  deserialize(etl::bit_stream_reader &reader, float &x);
 
  static void
  deserialize(etl::bit_stream_reader &reader, double &x);
 
private:
  telecommand();
 
  uint32_t m_frame_count;
 
  bool
  parse_tlm_req(msg_arbiter::msg &m, etl::bit_stream_reader &reader);
 
  bool
  parse_ring_buffer_logs(msg_arbiter::msg &m, etl::bit_stream_reader &reader);
 
  bool
  parse_storage_tlm(msg_arbiter::msg &m, etl::bit_stream_reader &reader,
                    packet_id id);
};
 
} // namespace satnogs::comms