fsfw/src/fsfw/osal/host/Clock.cpp

#include "fsfw/timemanager/Clock.h"

#include <chrono>

#include "fsfw/ipc/MutexGuard.h"
#include "fsfw/platform.h"
#include "fsfw/serviceinterface/ServiceInterface.h"

#if defined(PLATFORM_WIN)
#include <sysinfoapi.h>
#define timegm _mkgmtime
#elif defined(PLATFORM_UNIX)
#include <fstream>
#endif

using SystemClock = std::chrono::system_clock;

ReturnValue_t Clock::setClock(const timeval* time) {
  /* I don't know why someone would need to set a clock which is probably perfectly fine on a
  host system with internet access so this is not implemented for now. */
#if FSFW_CPP_OSTREAM_ENABLED == 1
  sif::warning << "Clock::setClock: Not implemented for host OSAL" << std::endl;
#else
  sif::printWarning("Clock::setClock: Not implemented for host OSAL\n");
#endif
  return returnvalue::OK;
}

ReturnValue_t Clock::getClock_timeval(timeval* time) {
#if defined(PLATFORM_WIN)
  auto now = std::chrono::system_clock::now();
  auto secondsChrono = std::chrono::time_point_cast<std::chrono::seconds>(now);
  auto epoch = now.time_since_epoch();
  time->tv_sec = std::chrono::duration_cast<std::chrono::seconds>(epoch).count();
  auto fraction = now - secondsChrono;
  time->tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(fraction).count();
  return returnvalue::OK;
#elif defined(PLATFORM_UNIX)
  timespec timeUnix;
  int status = clock_gettime(CLOCK_REALTIME, &timeUnix);
  if (status != 0) {
    return returnvalue::FAILED;
  }
  time->tv_sec = timeUnix.tv_sec;
  time->tv_usec = timeUnix.tv_nsec / 1000.0;
  return returnvalue::OK;
#else
#warning Clock::getClock_timeval() not implemented for your platform
#if FSFW_CPP_OSTREAM_ENABLED == 1
  sif::warning << "Clock::getUptime: Not implemented for found OS!" << std::endl;
#else
  sif::printWarning("Clock::getUptime: Not implemented for found OS!\n");
#endif
  return returnvalue::FAILED;
#endif
}

timeval Clock::getUptime() {
  timeval timeval;
#if defined(PLATFORM_WIN)
  auto uptime = std::chrono::milliseconds(GetTickCount64());
  auto secondsChrono = std::chrono::duration_cast<std::chrono::seconds>(uptime);
  timeval.tv_sec = secondsChrono.count();
  auto fraction = uptime - secondsChrono;
  timeval.tv_usec = std::chrono::duration_cast<std::chrono::microseconds>(fraction).count();
#elif defined(PLATFORM_UNIX)
  double uptimeSeconds;
  if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds) {
    // value is rounded down automatically
    timeval.tv_sec = uptimeSeconds;
    timeval.tv_usec = uptimeSeconds * (double)1e6 - (timeval.tv_sec * 1e6);
  }
#else
#warning Clock::getUptime() not implemented for your platform
#if FSFW_CPP_OSTREAM_ENABLED == 1
  sif::warning << "Clock::getUptime: Not implemented for found OS" << std::endl;
#endif
#endif
  return timeval;
}