settings.cpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS MCU software
 *
 *  Copyright (C) 2024-2025, 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 "settings.hpp"
#include "dsp/ccsds.hpp"
#include "error_handler.hpp"
#include "memory_monitor.hpp"
#include <satnogs-comms-lib/exception.hpp>
#include <zephyr/drivers/flash.h>
 
namespace scl = satnogs::comms::lib;
using radio   = scl::radio;
 
static const struct device *const flash = DEVICE_DT_GET(DT_NODELABEL(flash));
static constexpr size_t size   = DT_REG_SIZE(DT_NODELABEL(lfs1_partition));
constexpr off_t         offset = DT_REG_ADDR(DT_NODELABEL(lfs1_partition));
 
FS_FSTAB_DECLARE_ENTRY(DT_NODELABEL(lfs1));
struct fs_mount_t *mountpoint = &FS_FSTAB_ENTRY(DT_NODELABEL(lfs1));
namespace satnogs::comms
{

settings::settings() : m_runtime_settings_map{}
{
  k_mutex_init(&m_mtx);
  /*
   * If mount fails, it probably means that a double ECC flash error occured in
   * the directory header, erase the partition, reboot, and try to mount again.
   */
  try {
    if (fs_mount(mountpoint) < 0) {
      flash_erase(flash, offset, size);
      throw flash_read_exception(__FILE__, __LINE__);
    }
  } catch (const flash_read_exception &e) {
    auto &err = error_handler::get_instance();
    err.handle(e);
  }
 
  for (auto key : m_settings_map.keys()) {
    m_runtime_settings_map.insert({key, m_settings_map[key].default_value});
  }
  load();
}

void
settings::incr_boot_cnt()
{
  uint32_t cnt = get<settings::param::BOOT_COUNT>();
  set<settings::param::BOOT_COUNT>(++cnt);
  save_one<settings::param::BOOT_COUNT>();
}

bool
settings::deployed()
{
  return get<param::BOOT_COUNT>() > 0;
}

void
settings::get_tx_conf(lib::radio::interface iface, lib::radio::tx_conf &cnf)
{
  cnf.sync = dsp::ccsds::ASM;
  switch (iface) {
  case lib::radio::interface::UHF: {
    cnf.preamble_len  = 16;
    cnf.freq          = get<settings::param::UHF_TX_FREQ>();
    cnf.gain          = get<settings::param::UHF_TX_GAIN>();
    auto fsk          = get<settings::param::UHF_FSK_TX>();
    cnf.fsk.rate      = fsk.baudrate;
    cnf.fsk.mod_idx   = fsk.mod_idx;
    cnf.fsk.excess_bw = fsk.shaping;
  } break;
  case lib::radio::interface::SBAND: {
    cnf.preamble_len  = 32;
    cnf.freq          = get<settings::param::SBAND_TX_FREQ>();
    cnf.gain          = get<settings::param::SBAND_TX_GAIN>();
    auto fsk          = get<settings::param::SBAND_FSK_TX>();
    cnf.fsk.rate      = fsk.baudrate;
    cnf.fsk.mod_idx   = fsk.mod_idx;
    cnf.fsk.excess_bw = fsk.shaping;
  } break;
  default:
    throw lib::inval_arg_exception(__FILE__, __LINE__);
  }
}

void
settings::get_rx_conf(lib::radio::interface iface, lib::radio::rx_conf &cnf)
{
  cnf.preamble_len = 16;
  cnf.sync         = dsp::ccsds::ASM;
  switch (iface) {
  case lib::radio::interface::UHF: {
    cnf.freq            = get<settings::param::UHF_RX_FREQ>();
    cnf.gain.gain0_mode = get<settings::param::UHF_GAIN0_MODE>();
    cnf.gain.gain1_mode = get<settings::param::UHF_GAIN1_MODE>();
 
    if (cnf.gain.gain0_mode == lib::rf_frontend::gain_mode::AUTO) {
      cnf.gain.gain0.tgt = get<settings::param::UHF_GAIN0_TGT>();
    } else {
      cnf.gain.gain0.gain = get<settings::param::UHF_GAIN0_GAIN>();
    }
 
    if (cnf.gain.gain1_mode == lib::rf_frontend::gain_mode::AUTO) {
      auto agc1                = get<settings::param::UHF_GAIN1_AGC>();
      cnf.gain.gain1.agc.avgs  = agc1.avg;
      cnf.gain.gain1.agc.input = agc1.input;
      cnf.gain.gain1.agc.tgt   = agc1.tgt;
    } else {
      cnf.gain.gain1.gain = get<settings::param::UHF_GAIN1_GAIN>();
    }
    auto fsk          = get<settings::param::UHF_FSK_RX>();
    cnf.fsk.rate      = fsk.baudrate;
    cnf.fsk.mod_idx   = fsk.mod_idx;
    cnf.fsk.excess_bw = fsk.mod_idx;
    cnf.filter        = get<settings::param::UHF_FILTER>();
  } break;
  case lib::radio::interface::SBAND: {
    cnf.freq            = get<settings::param::SBAND_RX_FREQ>();
    cnf.gain.gain0_mode = get<settings::param::SBAND_GAIN0_MODE>();
    cnf.gain.gain1_mode = get<settings::param::SBAND_GAIN1_MODE>();
 
    if (cnf.gain.gain0_mode == lib::rf_frontend::gain_mode::AUTO) {
      cnf.gain.gain0.tgt = get<settings::param::SBAND_GAIN0_TGT>();
    } else {
      cnf.gain.gain0.gain = get<settings::param::SBAND_GAIN0_GAIN>();
    }
 
    if (cnf.gain.gain1_mode == lib::rf_frontend::gain_mode::AUTO) {
      auto agc1                = get<settings::param::SBAND_GAIN1_AGC>();
      cnf.gain.gain1.agc.avgs  = agc1.avg;
      cnf.gain.gain1.agc.input = agc1.input;
      cnf.gain.gain1.agc.tgt   = agc1.tgt;
    } else {
      cnf.gain.gain1.gain = get<settings::param::SBAND_GAIN1_GAIN>();
    }
    auto fsk          = get<settings::param::SBAND_FSK_RX>();
    cnf.fsk.rate      = fsk.baudrate;
    cnf.fsk.mod_idx   = fsk.mod_idx;
    cnf.fsk.excess_bw = fsk.mod_idx;
    cnf.filter        = get<settings::param::SBAND_FILTER>();
  } break;
  default:
    throw lib::inval_arg_exception(__FILE__, __LINE__);
  }
}

radio::clk_src
settings::radio_clk_src()
{
  auto x = get<param::PLL_REF_CLK_SRC>();
  switch (x) {
  case static_cast<uint32_t>(radio::clk_src::INTERNAL):
    return radio::clk_src::INTERNAL;
  case static_cast<uint32_t>(radio::clk_src::EXTERNAL):
    return radio::clk_src::EXTERNAL;
  default:
    return radio::clk_src::INTERNAL;
  }
}

void
settings::reset_all()
{
  reset_sequence(std::make_index_sequence<m_settings_map.size()>{});
}

void
settings::load()
{
  load_sequence(std::make_index_sequence<m_settings_map.size()>{});
}

void
settings::save()
{
  save_sequence(std::make_index_sequence<m_settings_map.size()>{});
}
 
} // namespace satnogs::comms