io_wdg.cpp

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
 */
 
#include "io_wdg.hpp"
#include "callbacks.hpp"
#include "error_handler.hpp"
#include "io.hpp"
#include "settings.hpp"
#include <etl/algorithm.h>
#include <satnogs-comms-lib/board.hpp>
#include <satnogs-comms-lib/radio.hpp>
#include <zephyr/kernel.h>
#include <zephyr/task_wdt/task_wdt.h>
 
namespace scl = satnogs::comms::lib;
 
namespace satnogs::comms
{
 
static uint32_t
min_to_ms(uint32_t mins)
{
  return (mins * 60000);
}
 
#if CONFIG_IO_WDG_PERIOD_MINS > 0
K_THREAD_STACK_DEFINE(io_wdg_thread_stack, CONFIG_IO_WDG_STACK_SIZE);
#endif

void
io_wdg::start()
{
#if CONFIG_IO_WDG_PERIOD_MINS > 0
  m_tid = k_thread_create(&m_thread_data, io_wdg_thread_stack,
                          K_THREAD_STACK_SIZEOF(io_wdg_thread_stack),
                          monitor_thread, NULL, NULL, NULL, CONFIG_IO_WDG_PRIO,
                          0, K_NO_WAIT);
  if (!m_tid) {
    k_oops();
  }
  k_thread_name_set(m_tid, "io_wdg");
#endif
}

uint32_t
io_wdg::period_mins()
{
  scoped_lock lock(&m_mtx);
  return m_period_mins;
}
 
void
io_wdg::monitor_thread(void *arg1, void *arg2, void *arg3)
{
  io_wdg &wdg = io_wdg::get_instance();
  auto   &s   = settings::get_instance();
 
  int64_t  ellapsed_time  = 0;
  uint32_t rx_frame_uhf   = 0;
  uint32_t rx_frame_sband = 0;
 
  int task_wdt_id = task_wdt_add(task_wdg_interval, task_wdt_callback,
                                 (void *)k_current_get());
  task_wdt_feed(task_wdt_id);
 
  /*
   * Make sure that the period is properly clamped both in the settings and
   * within the class. This will avoid any misconfiguration in case an invalid
   * value is somehow retrieved by the settings subsystem
   */
  wdg.set_period(s.get<settings::param::IO_WDG_PERIOD_MINS>());
 
  int64_t curr_time = k_uptime_get();
  while (1) {
    task_wdt_feed(task_wdt_id);
    wdg.reset();
 
    while (1) {
      int64_t  curr_time = k_uptime_get();
      uint32_t period_ms = min_to_ms(wdg.period_mins());
      if (wdg.m_last_reset_ts + period_ms > curr_time) {
        task_wdt_feed(task_wdt_id);
      } else {
        auto &log = logger::get_instance();
        log.log("IO watchdog resetting the system");
        /* Instruct a reboot. */
        sys_reboot(SYS_REBOOT_COLD);
        /* If this fails for any reason, rely on the IWDG */
        k_sleep(K_FOREVER);
      }
      k_sleep(K_SECONDS(10));
    }
  }
}

void
io_wdg::set_period(uint32_t period_mins)
{
  scoped_lock lock(&m_mtx);
  auto       &s = settings::get_instance();
  period_mins =
      etl::clamp(period_mins, io_wdg::min_period_mins, io_wdg::max_period_mins);
  s.set<settings::param::IO_WDG_PERIOD_MINS>(period_mins);
  m_period_mins = period_mins;
}
 
io_wdg::io_wdg()
    : m_period_mins(max_period_mins), // avoid calling the stack hungry settings
                                      // subsystem at construction
      m_last_reset_ts(0)
{
  k_mutex_init(&m_mtx);
}

void
io_wdg::reset()
{
  scoped_lock lock(&m_mtx);
  m_last_reset_ts = k_uptime_get();
}
 
} // namespace satnogs::comms