src/fsfw/fdir/FaultCounter.cpp

@@ -68,7 +68,7 @@ ReturnValue_t FaultCounter::getParameter(uint8_t domainId, uint8_t uniqueId,
       parameterWrapper->set(faultCount);
       break;
     case ParameterIds::TIMEOUT:
-      parameterWrapper->set(timer.timeout);
+      parameterWrapper->set(timer.getTimeoutMs());
       break;
     default:
       return INVALID_IDENTIFIER_ID;

src/fsfw/ipc/MutexGuard.h

@@ -26,11 +26,11 @@ class MutexGuard {
 #if FSFW_VERBOSE_LEVEL >= 1
     if (result == MutexIF::MUTEX_TIMEOUT) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "MutexGuard: Lock of mutex failed with timeout of " << timeoutMs
+      sif::error << "MutexGuard::" << context << ": Lock of mutex failed with timeout of "
-                 << " milliseconds!" << std::endl;
+                 << timeoutMs << " milliseconds!" << std::endl;
 #else
-      sif::printError("MutexGuard: Lock of mutex failed with timeout of %lu milliseconds\n",
+      sif::printError("MutexGuard::%s: Lock of mutex failed with timeout of %lu milliseconds\n",
-                      timeoutMs);
+                      context, timeoutMs);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 
     } else if (result != returnvalue::OK) {

src/fsfw/osal/linux/Clock.cpp

@@ -79,12 +79,17 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
   // TODO This is not posix compatible and delivers only seconds precision
   //  Linux specific file read but more precise.
   double uptimeSeconds;
-  if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds) {
+  std::ifstream ifile("/proc/uptime");
+  if (ifile.bad()) {
+    return returnvalue::FAILED;
+  }
+  if (ifile >> uptimeSeconds) {
     uptime->tv_sec = uptimeSeconds;
     uptime->tv_usec = uptimeSeconds * (double)1e6 - (uptime->tv_sec * 1e6);
-  }
     return returnvalue::OK;
   }
+  return returnvalue::FAILED;
+}
 
 // Wait for new FSFW Clock function delivering seconds uptime.
 // uint32_t Clock::getUptimeSeconds() {

src/fsfw/thermal/Heater.cpp

@@ -283,7 +283,7 @@ ReturnValue_t Heater::getParameter(uint8_t domainId, uint8_t uniqueId,
   }
   switch (uniqueId) {
     case 0:
-      parameterWrapper->set(heaterOnCountdown.timeout);
+      parameterWrapper->set(heaterOnCountdown.getTimeoutMs());
       break;
     default:
       return INVALID_IDENTIFIER_ID;

src/fsfw/timemanager/Countdown.cpp

@@ -1,49 +1,62 @@
 #include "fsfw/timemanager/Countdown.h"
 
-Countdown::Countdown(uint32_t initialTimeout, bool startImmediately) : timeout(initialTimeout) {
+#include "fsfw/globalfunctions/timevalOperations.h"
+
+Countdown::Countdown(uint32_t initialTimeout, bool startImmediately) {
   if (startImmediately) {
     setTimeout(initialTimeout);
   } else {
-    timeout = initialTimeout;
+    timeout.tv_sec = initialTimeout / 1000;
+    timeout.tv_usec = (initialTimeout % 1000) * 1000;
   }
 }
 
-Countdown::~Countdown() {}
+Countdown::~Countdown() = default;
 
 ReturnValue_t Countdown::setTimeout(uint32_t milliseconds) {
-  ReturnValue_t returnValue = Clock::getUptime(&startTime);
+  timeout.tv_sec = milliseconds / 1000;
-  timeout = milliseconds;
+  timeout.tv_usec = (milliseconds % 1000) * 1000;
-  return returnValue;
+  return Clock::getClock_timeval(&startTime);
 }
 
 bool Countdown::hasTimedOut() const {
-  if (uint32_t(this->getCurrentTime() - startTime) >= timeout) {
+  // Account for system clock going back in time.
+  if (getCurrentTime() < startTime) {
     return true;
-  } else {
-    return false;
   }
+  if (getCurrentTime() - startTime >= timeout) {
+    return true;
+  }
+  return false;
 }
 
 bool Countdown::isBusy() const { return !hasTimedOut(); }
 
-ReturnValue_t Countdown::resetTimer() { return setTimeout(timeout); }
+ReturnValue_t Countdown::resetTimer() { return setTimeoutTv(timeout); }
 
 void Countdown::timeOut() { startTime = this->getCurrentTime() - timeout; }
 
 uint32_t Countdown::getRemainingMillis() const {
-  // We fetch the time before the if-statement
-  // to be sure that the return is in
-  // range 0 <= number <= timeout
-  uint32_t currentTime = this->getCurrentTime();
   if (this->hasTimedOut()) {
     return 0;
-  } else {
-    return (startTime + timeout) - currentTime;
   }
+  timeval remainingMillisTv = (startTime + timeout) - this->getCurrentTime();
+  return remainingMillisTv.tv_sec * 1000 + remainingMillisTv.tv_usec / 1000;
 }
 
-uint32_t Countdown::getCurrentTime() const {
+uint32_t Countdown::timevalToMs(timeval &tv) { return tv.tv_sec * 1000 + tv.tv_usec / 1000; }
-  uint32_t currentTime;
+
-  Clock::getUptime(&currentTime);
+ReturnValue_t Countdown::setTimeoutTv(timeval tv) {
+  timeout = tv;
+  return Clock::getClock_timeval(&startTime);
+}
+
+uint32_t Countdown::getTimeoutMs() const { return timeout.tv_sec * 1000 + timeout.tv_usec / 1000; }
+
+timeval Countdown::getTimeout() const { return timeout; }
+
+timeval Countdown::getCurrentTime() const {
+  timeval currentTime{};
+  Clock::getClock_timeval(&currentTime);
   return currentTime;
 }

src/fsfw/timemanager/Countdown.h

@@ -6,6 +6,10 @@
 /**
  *
  * Countdown keeps track of a timespan.
+ * This class uses the system clock internally to achieve
+ * a high resolution. This means that the API is only partially
+ * resistant against time jumps. The user must take care to account
+ * for time jumps in some from if this relevant.
  *
  * Countdown::resetTimer restarts the timer.
  * Countdown::setTimeout sets a new countdown duration and resets.
@@ -39,6 +43,8 @@ class Countdown {
    * @return Returnvalue from Clock::getUptime
    */
   ReturnValue_t setTimeout(uint32_t milliseconds);
+  ReturnValue_t setTimeoutTv(timeval tv);
+
   /**
    * Returns true if the countdown duration has passed.
    *
@@ -61,22 +67,31 @@ class Countdown {
    * Returns the remaining milliseconds (0 if timeout)
    */
   uint32_t getRemainingMillis() const;
+
+  uint32_t getTimeoutMs() const;
+
+  timeval getTimeout() const;
+
   /**
    * Makes hasTimedOut() return true
    */
   void timeOut();
-  /**
+
-   * Internal countdown duration in milliseconds
+  static inline uint32_t timevalToMs(timeval& tv);
-   */
-  uint32_t timeout;
 
  private:
   /**
-   * Last time the timer was started (uptime)
+   * Start time of the countdown.
    */
-  uint32_t startTime = 0;
+  timeval startTime{};
 
-  uint32_t getCurrentTime() const;
+  /**
+   * Timeout as timeval type. The countdown has timed out when the
+   * current time exceeds the start time plus the timeout.
+   */
+  timeval timeout{};
+
+  timeval getCurrentTime() const;
 };
 
 #endif /* FSFW_TIMEMANAGER_COUNTDOWN_H_ */

unittests/timemanager/TestCountdown.cpp

@@ -1,15 +1,18 @@
 #include <fsfw/timemanager/Countdown.h>
 
 #include <catch2/catch_test_macros.hpp>
+#include <chrono>
+#include <thread>
 
 #include "CatchDefinitions.h"
 
+static constexpr bool TEST_LONGER_CD = false;
 TEST_CASE("Countdown Tests", "[TestCountdown]") {
   INFO("Countdown Tests");
   Countdown count(20);
-  REQUIRE(count.timeout == 20);
+  REQUIRE(count.getTimeoutMs() == 20);
   REQUIRE(count.setTimeout(100) == static_cast<uint16_t>(returnvalue::OK));
-  REQUIRE(count.timeout == 100);
+  REQUIRE(count.getTimeoutMs() == 100);
   REQUIRE(count.setTimeout(150) == static_cast<uint16_t>(returnvalue::OK));
   REQUIRE(count.isBusy());
   REQUIRE(not count.hasTimedOut());
@@ -25,4 +28,19 @@ TEST_CASE("Countdown Tests", "[TestCountdown]") {
   count.resetTimer();
   REQUIRE(not count.hasTimedOut());
   REQUIRE(count.isBusy());
+  count.setTimeout(100);
+  REQUIRE(not count.hasTimedOut());
+  std::this_thread::sleep_for(std::chrono::milliseconds(50));
+  REQUIRE(not count.hasTimedOut());
+  std::this_thread::sleep_for(std::chrono::milliseconds(50));
+  REQUIRE(count.hasTimedOut());
+
+  // Takes longer, disabled by default
+  if (TEST_LONGER_CD) {
+    count.setTimeout(2500);
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+    REQUIRE(not count.hasTimedOut());
+    std::this_thread::sleep_for(std::chrono::milliseconds(1500));
+    REQUIRE(count.hasTimedOut());
+  }
 }