thermal.cpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS MCU software
 *
 *  Copyright (C) 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 "thermal.hpp"
#include <callbacks.hpp>
#include <io.hpp>
#include <logger.hpp>
#include <satnogs-comms-lib/board.hpp>
#include <startup.hpp>
 
namespace scl = satnogs::comms::lib;
 
namespace satnogs::comms
{
 
static struct k_thread thermal_thread_data;
K_THREAD_STACK_DEFINE(thermal_thread_stack,
                      CONFIG_THERMAL_MONITOR_THREAD_STACK_SIZE);
 
thermal::thermal() : m_uhf_triggered(false), m_sband_triggered(false) {}

void
thermal::start()
{
  m_tid = k_thread_create(&thermal_thread_data, thermal_thread_stack,
                          K_THREAD_STACK_SIZEOF(thermal_thread_stack),
                          thermal_thread, NULL, NULL, NULL,
                          CONFIG_THERMAL_MONITOR_THREAD_PRIORITY, 0, K_NO_WAIT);
  if (!m_tid) {
    k_oops();
  }
  k_thread_name_set(m_tid, "thermal_monitor");
}
 
void
thermal::thermal_thread(void *arg1, void *arg2, void *arg3)
{
  static_assert(task_wdg_period / 2 > CONFIG_THERMAL_MONITOR_PERIOD_SECS * 1000,
                "Wrong configuration");
  int task_wdt_id =
      task_wdt_add(60000, task_wdt_callback, (void *)k_current_get());
 
  while (1) {
    task_wdt_feed(task_wdt_id);
    k_sleep(K_SECONDS(CONFIG_THERMAL_MONITOR_PERIOD_SECS));
 
    /* Step 1: Get temperatures from the various sensors and check their
     * validity
     */
    auto &th         = thermal::get_instance();
    auto &log        = logger::get_instance();
    auto &radio_ctrl = io::get_instance().radio_ctrl();
    auto &s          = settings::get_instance();
    try {
      float t = scl::board::get_instance().temperature(
          scl::temperature_sensor::UHF_PA);
 
      /* Check if the reported temperature is within the expected range */
      if (std::isfinite(t) &&
          t > s.get<settings::param::THERMAL_MIN_VALID_TEMP>() &&
          t < s.get<settings::param::THERMAL_MAX_VALID_TEMP>()) {
        /* If previously invalid, reset the moving average */
        if (th.m_state.uhf_sensor_valid == false) {
          th.m_uhf_temp.reset(t);
        } else {
          th.m_uhf_temp(t);
        }
        th.m_state.uhf_sensor_valid = true;
 
      } else {
        th.m_state.uhf_sensor_valid = false;
      }
    } catch (...) {
      th.m_state.uhf_sensor_valid = false;
    }
 
    try {
      float t = scl::board::get_instance().temperature(
          scl::temperature_sensor::SBAND_PA);
      /* Check if the reported temperature is within the expected range */
      if (std::isfinite(t) &&
          t > s.get<settings::param::THERMAL_MIN_VALID_TEMP>() &&
          t < s.get<settings::param::THERMAL_MAX_VALID_TEMP>()) {
        /* If previously invalid, reset the moving average */
        if (th.m_state.sband_sensor_valid == false) {
          th.m_sband_temp.reset(t);
        } else {
          th.m_sband_temp(t);
        }
        th.m_state.sband_sensor_valid = true;
 
      } else {
        th.m_state.sband_sensor_valid = false;
      }
    } catch (...) {
      th.m_state.sband_sensor_valid = false;
    }
 
    try {
      float t =
          scl::board::get_instance().temperature(scl::temperature_sensor::PCB);
      /* Check if the reported temperature is within the expected range */
      if (std::isfinite(t) &&
          t > s.get<settings::param::THERMAL_MIN_VALID_TEMP>() &&
          t < s.get<settings::param::THERMAL_MAX_VALID_TEMP>()) {
        /* If previously invalid, reset the moving average */
        if (th.m_state.pcb_sensor_valid == false) {
          th.m_pcb_temp.reset(t);
        } else {
          th.m_pcb_temp(t);
        }
        th.m_state.pcb_sensor_valid = true;
 
      } else {
        th.m_state.pcb_sensor_valid = false;
      }
    } catch (...) {
      th.m_state.pcb_sensor_valid = false;
    }
 
    /* Step 2: Take actions! */
 
    /* UHF interface */
    if (th.m_state.uhf_sensor_valid) {
      if (th.m_state.uhf_triggered) {
        if (th.m_uhf_temp() <
            s.get<settings::param::THERMAL_UHF_ENABLE_TEMP>()) {
          th.m_state.uhf_triggered = false;
          log.log("Thermal UHF: Re-enabling UHF interface");
          radio_ctrl.enable(scl::radio::interface::UHF);
        }
      } else {
        if (th.m_uhf_temp() >
            s.get<settings::param::THERMAL_UHF_SHUTDOWN_TEMP>()) {
          th.m_state.uhf_triggered = true;
          log.log("Thermal UHF: Disabling UHF interface");
          radio_ctrl.disable(scl::radio::interface::UHF);
        }
      }
    }
    /* Use the PCB sensor as backup */
    else if (th.m_state.pcb_sensor_valid) {
      if (th.m_state.uhf_triggered) {
        if (th.m_pcb_temp() <
            s.get<settings::param::THERMAL_PCB_ENABLE_TEMP>()) {
          th.m_state.uhf_triggered = false;
          log.log("Thermal UHF: Re-enabling UHF interface from backup sensor");
          radio_ctrl.enable(scl::radio::interface::UHF);
        }
      } else {
        if (th.m_pcb_temp() >
            s.get<settings::param::THERMAL_PCB_SHUTDOWN_TEMP>()) {
          th.m_state.uhf_triggered = true;
          log.log("Thermal UHF: Disabling UHF interface from backup sensor");
          radio_ctrl.disable(scl::radio::interface::UHF);
        }
      }
    }
    /* We cannot do much at this point. Re-enable the interface and pray! */
    else {
      if (th.m_state.uhf_triggered) {
        th.m_state.uhf_triggered = false;
        log.log("Thermal UHF: Re-enabling UHF interface. Lost all sensors");
        radio_ctrl.enable(scl::radio::interface::UHF);
      }
    }
 
    /* S-band interface*/
    if (th.m_state.sband_sensor_valid) {
      if (th.m_state.sband_triggered) {
        if (th.m_sband_temp() <
            s.get<settings::param::THERMAL_SBAND_ENABLE_TEMP>()) {
          th.m_state.sband_triggered = false;
          log.log("Thermal S-band: Re-enabling S-band interface");
          radio_ctrl.enable(scl::radio::interface::SBAND);
        }
      } else {
        if (th.m_sband_temp() >
            s.get<settings::param::THERMAL_SBAND_SHUTDOWN_TEMP>()) {
          th.m_state.sband_triggered = true;
          log.log("Thermal S-band: Disabling S-band interface");
          radio_ctrl.disable(scl::radio::interface::SBAND);
        }
      }
    }
    /* Use the PCB sensor as backup */
    else if (th.m_state.pcb_sensor_valid) {
      if (th.m_state.sband_triggered) {
        if (th.m_pcb_temp() <
            s.get<settings::param::THERMAL_PCB_ENABLE_TEMP>()) {
          th.m_state.sband_triggered = false;
          log.log("Thermal S-band: Re-enabling S-band interface from backup "
                  "sensor");
          radio_ctrl.enable(scl::radio::interface::SBAND);
        }
      } else {
        if (th.m_pcb_temp() >
            s.get<settings::param::THERMAL_PCB_SHUTDOWN_TEMP>()) {
          th.m_state.sband_triggered = true;
          log.log(
              "Thermal S-band: Disabling S-band interface from backup sensor");
          radio_ctrl.disable(scl::radio::interface::SBAND);
        }
      }
    }
    /* We cannot do much at this point. Re-enable the interface and pray! */
    else {
      if (th.m_state.sband_triggered) {
        th.m_state.sband_triggered = false;
        log.log(
            "Thermal S-band: Re-enabling S-band interface. Lost all sensors");
        radio_ctrl.enable(scl::radio::interface::SBAND);
      }
    }
  }
}
 
} // namespace satnogs::comms