telemetry.cpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS MCU software
 *
 *  Copyright (C) 2023-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 "telemetry.hpp"
#include "logger.hpp"
 
namespace scl = satnogs::comms::lib;
 
namespace satnogs::comms
{
 
void
telemetry::serialize(etl::bit_stream_writer &writer, float x)
{
  static_assert(sizeof(x) == sizeof(uint32_t), "Unsupported float size");
  uint32_t u;
  std::memcpy(&u, &x, 4);
  writer.write<uint32_t>(u, 32);
}
 
void
telemetry::serialize(etl::bit_stream_writer &writer, double x)
{
  static_assert(sizeof(x) == sizeof(uint64_t), "Unsupported double size");
  uint64_t u;
  std::memcpy(&u, &x, 8);
  writer.write<uint64_t>(u, 64);
}
 
void
telemetry::send_ring_buffer_logs_tlm(msg_arbiter::msg &m,
                                     const size_t      num_of_logs)
{
  auto &l   = logger::get_instance();
  auto &arb = msg_arbiter::get_instance();
  auto &tlc = telecommand::get_instance();
 
  logger::ring_buf_msg data;
 
  telemetry::ccsds_tm_header tm_header;
  tm_header.apid =
      static_cast<uint16_t>(telemetry::apid::RING_BUFFER_LOGS_RESP);
  tm_header.count = tlc.get_frame_count();
 
  size_t ring_buffer_size = l.get_ring_buffer_size();
 
  for (size_t i = 0; i < etl::min(num_of_logs, ring_buffer_size); i++) {
 
    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);
 
    l.get_ring_buffer_log(data, i);
 
    bit_stream_pld.write<uint8_t>((uint8_t)data.m_t_src, 8);
    bit_stream_pld.write<uint64_t>(data.m_t_posix, 64);
 
    memcpy(bit_stream_pld.begin() + sizeof(data.m_t_src) +
               sizeof(data.m_t_posix),
           data.m_log.c_str(), data.m_log.size());
 
    bit_stream_pld.skip(8 * data.m_log.size());
    bit_stream_pld.write<uint8_t>('\0', 8);
 
    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;
    arb.fwd(0, 0, m, m.iface, K_FOREVER);
  }
}
 
void
telemetry::send_all_ota_sessions_info_tlm(msg_arbiter::msg &m)
{
  auto        &ota = ota::get_instance();
  ota::session session_info;
  auto        &arb = msg_arbiter::get_instance();
  auto        &tlc = telecommand::get_instance();
 
  telemetry::ccsds_tm_header tm_header;
  tm_header.apid  = static_cast<uint16_t>(telemetry::apid::OTA_SESSION_INFO);
  tm_header.count = tlc.get_frame_count();
 
  for (uint32_t session_id = 0; session_id < CONFIG_OTA_MAX_SESSIONS;
       session_id++) {
    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);
 
    ota.get_session_info(session_id, session_info);
    bit_stream_pld.write<uint8_t>(session_id, 8);
    bit_stream_pld.write<uint8_t>(
        static_cast<uint8_t>(session_info.destination), 8);
    bit_stream_pld.write<uint8_t>(static_cast<uint8_t>(session_info.slot), 8);
    bit_stream_pld.write<bool>(session_info.active, 1);
    bit_stream_pld.write<bool>(session_info.applied, 1);
    bit_stream_pld.write<uint32_t>(session_info.total_size, 32);
    bit_stream_pld.write<uint32_t>(session_info.ack, 32);
    bit_stream_pld.write<uint8_t>(static_cast<uint8_t>(session_info.time_src),
                                  8);
    bit_stream_pld.write<uint8_t>(session_info.t.tm_sec, 8);
    bit_stream_pld.write<uint8_t>(session_info.t.tm_min, 8);
    bit_stream_pld.write<uint8_t>(session_info.t.tm_hour, 8);
    bit_stream_pld.write<uint8_t>(session_info.t.tm_mday, 8);
    bit_stream_pld.write<uint8_t>(session_info.t.tm_mon, 8);
    bit_stream_pld.write<uint8_t>(session_info.t.tm_year, 16);
    bit_stream_pld.write<uint8_t>(session_info.t.tm_wday, 8);
    bit_stream_pld.write<uint8_t>(session_info.t.tm_yday, 8);
    bit_stream_pld.write<int8_t>(session_info.t.tm_isdst, 8);
    bit_stream_pld.write<uint8_t>(0U, 6);
    for (uint8_t i = 0; i < 32; i++) {
      bit_stream_pld.write<int8_t>(session_info.sha256[i], 8);
    }
    for (size_t i = 0; i < session_info.name.size(); ++i) {
      bit_stream_pld.write<uint8_t>(static_cast<uint8_t>(session_info.name[i]),
                                    8);
    }
    // Append the null termination byte for proper render at the MCS
    bit_stream_pld.write<uint8_t>(0x0, 8);
    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;
    arb.fwd(0, 0, m, m.iface, K_FOREVER);
  }
}
 
} // namespace satnogs::comms