clocks suck a little less

CMakeLists.txt

@@ -153,7 +153,7 @@ if(FSFW_BUILD_TESTS)
       "${MSG_PREFIX} Building the FSFW unittests in addition to the static library"
   )
   # Check whether the user has already installed Catch2 first
-  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
+  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION} QUIET)
   # Not installed, so use FetchContent to download and provide Catch2
   if(NOT Catch2_FOUND)
     message(

automation/Dockerfile

@@ -5,7 +5,7 @@ RUN apt-get --yes upgrade
 
 #tzdata is a dependency, won't install otherwise
 ARG DEBIAN_FRONTEND=noninteractive
-RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping python3 pip doxygen graphviz rsync
+RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping python3 pip doxygen graphviz rsync wget qemu-system-arm
 
 RUN python3 -m pip install sphinx breathe
 
@@ -21,8 +21,12 @@ RUN git clone https://github.com/ETLCPP/etl.git && \
         cmake -B build . && \
         cmake --install build/
 
+RUN wget -qO- https://buggy.irs.uni-stuttgart.de/rtems_releases/rtems6-12.2.1.tar.bz2 | tar -xj -C /opt/
+
+ENV PATH="$PATH:/opt/rtems/6/bin"
+
 #ssh needs a valid user to work
-RUN adduser --uid 114 jenkins
+RUN adduser -q --uid 114 jenkins
 
 #add documentation server to known hosts
 RUN echo "|1|/LzCV4BuTmTb2wKnD146l9fTKgQ=|NJJtVjvWbtRt8OYqFgcYRnMQyVw= ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBNL8ssTonYtgiR/6RRlSIK9WU1ywOcJmxFTLcEblAwH7oifZzmYq3XRfwXrgfMpylEfMFYfCU8JRqtmi19xc21A=" >> /etc/ssh/ssh_known_hosts

automation/Jenkinsfile

@@ -3,11 +3,12 @@ pipeline {
         BUILDDIR_HOST = 'cmake-build-tests-host'
         BUILDDIR_LINUX = 'cmake-build-tests-linux'
         BUILDDIR_FREERTOS = 'cmake-build-tests-freertos'
+        BUILDDIR_RTEMS = 'cmake-build-tests-rtems'
         DOCDDIR = 'cmake-build-documentation'
     }
     agent {
         docker { 
-            image 'fsfw-ci:d6'
+            image 'fsfw-ci:d7'
             args '--network host --sysctl fs.mqueue.msg_max=100'
         }
     }
@@ -48,6 +49,17 @@ pipeline {
                 }
             }
         }
+        stage('rtems') {
+            steps {
+                sh 'rm -rf $BUILDDIR_RTEMS'
+
+                dir(BUILDDIR_RTEMS) {
+                    sh 'cmake -DFSFW_OSAL=rtems -DFSFW_BUILD_TESTS=ON -DFSFW_TESTS_GEN_COV=OFF -DFSFW_CICD_BUILD=ON -DCMAKE_TOOLCHAIN_FILE=../unittests/testcfg/rtems/cmake/aarch64-rtems6-toolchain.cmake ..'
+                    sh 'cmake --build . -j4'
+                    sh 'qemu-system-aarch64 -no-reboot -nographic -serial mon:stdio -semihosting -machine virt,gic-version=3 -cpu cortex-a72 -m 4000  -kernel fsfw-tests'
+                }
+            }
+        }
         stage('Documentation') {
             when {
                 branch 'development'

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -321,8 +321,7 @@ void DeviceHandlerBase::doStateMachine() {
       if (mode != currentMode) {
         break;
       }
-      uint32_t currentUptime;
-      Clock::getUptime(&currentUptime);
+      uint32_t currentUptime = Clock::getUptime_ms();
       if (currentUptime - timeoutStart >= childTransitionDelay) {
 #if FSFW_VERBOSE_LEVEL >= 1 && FSFW_OBJ_EVENT_TRANSLATION == 0
         char printout[60];
@@ -346,8 +345,7 @@ void DeviceHandlerBase::doStateMachine() {
       setMode(_MODE_WAIT_ON);
       break;
     case _MODE_WAIT_ON: {
-      uint32_t currentUptime;
-      Clock::getUptime(&currentUptime);
+      uint32_t currentUptime = Clock::getUptime_ms();
       if (powerSwitcher != nullptr and
           currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
         triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT, 0);
@@ -366,8 +364,7 @@ void DeviceHandlerBase::doStateMachine() {
       }
     } break;
     case _MODE_WAIT_OFF: {
-      uint32_t currentUptime;
-      Clock::getUptime(&currentUptime);
+      uint32_t currentUptime = Clock::getUptime_ms();
 
       if (powerSwitcher == nullptr) {
         setMode(MODE_OFF);
@@ -577,7 +574,7 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
     modeHelper.modeChanged(newMode, newSubmode);
     announceMode(false);
   }
-  Clock::getUptime(&timeoutStart);
+  timeoutStart = Clock::getUptime_ms();
 
   if (mode == MODE_OFF and thermalSet != nullptr) {
     ReturnValue_t result = thermalSet->read();

src/fsfw/osal/freertos/Clock.cpp

@@ -11,19 +11,6 @@
 // TODO sanitize input?
 // TODO much of this code can be reused for tick-only systems
 
-uint32_t Clock::getTicksPerSecond(void) { return 1000; }
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-  timeval time_timeval;
-
-  ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-
-  return setClock(&time_timeval);
-}
-
 ReturnValue_t Clock::setClock(const timeval* time) {
   timeval uptime = getUptime();
 
@@ -44,83 +31,15 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
   return returnvalue::OK;
 }
 
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-  *uptime = getUptime();
-
-  return returnvalue::OK;
-}
-
 timeval Clock::getUptime() {
   TickType_t ticksSinceStart = xTaskGetTickCount();
   return Timekeeper::ticksToTimeval(ticksSinceStart);
 }
 
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-  timeval uptime = getUptime();
-  *uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
-  return returnvalue::OK;
-}
-
 // uint32_t Clock::getUptimeSeconds() {
 //	timeval uptime = getUptime();
 //	return uptime.tv_sec;
 // }
 
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-  timeval time_timeval;
-  ReturnValue_t result = getClock_timeval(&time_timeval);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  *time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
-  return returnvalue::OK;
-}
 
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-  timeval time_timeval;
-  ReturnValue_t result = getClock_timeval(&time_timeval);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  struct tm time_tm;
 
-  gmtime_r(&time_timeval.tv_sec, &time_tm);
-
-  time->year = time_tm.tm_year + 1900;
-  time->month = time_tm.tm_mon + 1;
-  time->day = time_tm.tm_mday;
-
-  time->hour = time_tm.tm_hour;
-  time->minute = time_tm.tm_min;
-  time->second = time_tm.tm_sec;
-
-  time->usecond = time_timeval.tv_usec;
-
-  return returnvalue::OK;
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
-  struct tm time_tm = {};
-
-  time_tm.tm_year = from->year - 1900;
-  time_tm.tm_mon = from->month - 1;
-  time_tm.tm_mday = from->day;
-
-  time_tm.tm_hour = from->hour;
-  time_tm.tm_min = from->minute;
-  time_tm.tm_sec = from->second;
-
-  time_tm.tm_isdst = 0;
-
-  time_t seconds = timegm(&time_tm);
-
-  to->tv_sec = seconds;
-  to->tv_usec = from->usecond;
-
-  return returnvalue::OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-  *JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24. / 3600.;
-  return returnvalue::OK;
-}

src/fsfw/osal/host/Clock.cpp

@@ -15,27 +15,6 @@
 
 using SystemClock = std::chrono::system_clock;
 
-uint32_t Clock::getTicksPerSecond(void) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::warning << "Clock::getTicksPerSecond: Not implemented for host OSAL" << std::endl;
-#else
-  sif::printWarning("Clock::getTicksPerSecond: Not implemented for host OSAL\n");
-#endif
-  /* To avoid division by zero */
-  return 1;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* 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::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. */
@@ -66,6 +45,7 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
   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
@@ -75,15 +55,6 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 #endif
 }
 
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-  if (time == nullptr) {
-    return returnvalue::FAILED;
-  }
-  using namespace std::chrono;
-  *time = duration_cast<microseconds>(system_clock::now().time_since_epoch()).count();
-  return returnvalue::OK;
-}
-
 timeval Clock::getUptime() {
   timeval timeval;
 #if defined(PLATFORM_WIN)
@@ -100,6 +71,7 @@ timeval Clock::getUptime() {
     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
@@ -107,66 +79,3 @@ timeval Clock::getUptime() {
   return timeval;
 }
 
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-  *uptime = getUptime();
-  return returnvalue::OK;
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-  timeval uptime = getUptime();
-  *uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
-  return returnvalue::OK;
-}
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-  /* Do some magic with chrono (C++20!) */
-  /* Right now, the library doesn't have the new features to get the required values yet.
-  so we work around that for now. */
-  auto now = SystemClock::now();
-  auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(now);
-  auto fraction = now - seconds;
-  time_t tt = SystemClock::to_time_t(now);
-  ReturnValue_t result = checkOrCreateClockMutex();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  MutexGuard helper(timeMutex);
-  // gmtime writes its output in a global buffer which is not Thread Safe
-  // Therefore we have to use a Mutex here
-  struct tm* timeInfo;
-  timeInfo = gmtime(&tt);
-  time->year = timeInfo->tm_year + 1900;
-  time->month = timeInfo->tm_mon + 1;
-  time->day = timeInfo->tm_mday;
-  time->hour = timeInfo->tm_hour;
-  time->minute = timeInfo->tm_min;
-  time->second = timeInfo->tm_sec;
-  auto usecond = std::chrono::duration_cast<std::chrono::microseconds>(fraction);
-  time->usecond = usecond.count();
-  return returnvalue::OK;
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
-  struct tm time_tm {};
-
-  time_tm.tm_year = from->year - 1900;
-  time_tm.tm_mon = from->month - 1;
-  time_tm.tm_mday = from->day;
-
-  time_tm.tm_hour = from->hour;
-  time_tm.tm_min = from->minute;
-  time_tm.tm_sec = from->second;
-  time_tm.tm_isdst = 0;
-
-  time_t seconds = timegm(&time_tm);
-
-  to->tv_sec = seconds;
-  to->tv_usec = from->usecond;
-  // Fails in 2038..
-  return returnvalue::OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-  *JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24. / 3600.;
-  return returnvalue::OK;
-}

src/fsfw/osal/linux/Clock.cpp

@@ -10,26 +10,6 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-uint32_t Clock::getTicksPerSecond() {
-  uint32_t ticks = sysconf(_SC_CLK_TCK);
-  return ticks;
-}
-
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-  timespec timeUnix{};
-  timeval timeTimeval{};
-  convertTimeOfDayToTimeval(time, &timeTimeval);
-  timeUnix.tv_sec = timeTimeval.tv_sec;
-  timeUnix.tv_nsec = (__syscall_slong_t)timeTimeval.tv_usec * 1000;
-
-  int status = clock_settime(CLOCK_REALTIME, &timeUnix);
-  if (status != 0) {
-    // TODO errno
-    return returnvalue::FAILED;
-  }
-  return returnvalue::OK;
-}
-
 ReturnValue_t Clock::setClock(const timeval* time) {
   timespec timeUnix{};
   timeUnix.tv_sec = time->tv_sec;
@@ -53,104 +33,12 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
   return returnvalue::OK;
 }
 
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-  timeval timeVal{};
-  ReturnValue_t result = getClock_timeval(&timeVal);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  *time = static_cast<uint64_t>(timeVal.tv_sec) * 1e6 + timeVal.tv_usec;
-
-  return returnvalue::OK;
-}
-
 timeval Clock::getUptime() {
-  timeval uptime{};
-  auto result = getUptime(&uptime);
-  if (result != returnvalue::OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "Clock::getUptime: Error getting uptime" << std::endl;
-#endif
-  }
-  return uptime;
-}
-
-ReturnValue_t Clock::getUptime(timeval* uptime) {
-  // TODO This is not posix compatible and delivers only seconds precision
-  //  Linux specific file read but more precise.
+  timeval uptime{0,0};
   double uptimeSeconds;
   if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds) {
-    uptime->tv_sec = uptimeSeconds;
-    uptime->tv_usec = uptimeSeconds * (double)1e6 - (uptime->tv_sec * 1e6);
+    uptime.tv_sec = uptimeSeconds;
+    uptime.tv_usec = uptimeSeconds * (double)1e6 - (uptime.tv_sec * 1e6);
   }
-  return returnvalue::OK;
-}
-
-// Wait for new FSFW Clock function delivering seconds uptime.
-// uint32_t Clock::getUptimeSeconds() {
-//	//TODO This is not posix compatible and delivers only seconds precision
-//	struct sysinfo sysInfo;
-//	int result = sysinfo(&sysInfo);
-//	if(result != 0){
-//		return returnvalue::FAILED;
-//	}
-//	return sysInfo.uptime;
-//}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-  timeval uptime{};
-  ReturnValue_t result = getUptime(&uptime);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  *uptimeMs = uptime.tv_sec * 1e3 + uptime.tv_usec / 1e3;
-  return returnvalue::OK;
-}
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-  timespec timeUnix{};
-  int status = clock_gettime(CLOCK_REALTIME, &timeUnix);
-  if (status != 0) {
-    // TODO errno
-    return returnvalue::FAILED;
-  }
-  ReturnValue_t result = checkOrCreateClockMutex();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  MutexGuard helper(timeMutex);
-  // gmtime writes its output in a global buffer which is not Thread Safe
-  // Therefore we have to use a Mutex here
-  struct std::tm* timeInfo;
-  timeInfo = gmtime(&timeUnix.tv_sec);
-  time->year = timeInfo->tm_year + 1900;
-  time->month = timeInfo->tm_mon + 1;
-  time->day = timeInfo->tm_mday;
-  time->hour = timeInfo->tm_hour;
-  time->minute = timeInfo->tm_min;
-  time->second = timeInfo->tm_sec;
-  time->usecond = timeUnix.tv_nsec / 1000.0;
-
-  return returnvalue::OK;
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
-  std::tm fromTm{};
-  // Note: Fails for years before AD
-  fromTm.tm_year = from->year - 1900;
-  fromTm.tm_mon = from->month - 1;
-  fromTm.tm_mday = from->day;
-  fromTm.tm_hour = from->hour;
-  fromTm.tm_min = from->minute;
-  fromTm.tm_sec = from->second;
-  fromTm.tm_isdst = 0;
-
-  to->tv_sec = timegm(&fromTm);
-  to->tv_usec = from->usecond;
-  return returnvalue::OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-  *JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24. / 3600.;
-  return returnvalue::OK;
-}
+  return uptime;
+}

src/fsfw/osal/rtems/BinarySemaphore.cpp

@@ -2,6 +2,8 @@
 
 #include <rtems/rtems/sem.h>
 
+//TODO
+
 BinarySemaphore::BinarySemaphore() {}
 
 BinarySemaphore::~BinarySemaphore() {}

src/fsfw/osal/rtems/Clock.cpp

@@ -6,20 +6,21 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/osal/rtems/RtemsBasic.h"
 
-uint32_t Clock::getTicksPerSecond(void) {
-  rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
-  return static_cast<uint32_t>(ticks_per_second);
-}
 
-ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+ReturnValue_t Clock::setClock(const timeval* time) {
+  TimeOfDay_t time_tod;
+  ReturnValue_t result = convertTimevalToTimeOfDay(time, &time_tod);
+  if (result != returnvalue::OK) {
+    return result;
+  }
   rtems_time_of_day timeRtems;
-  timeRtems.year = time->year;
-  timeRtems.month = time->month;
-  timeRtems.day = time->day;
-  timeRtems.hour = time->hour;
-  timeRtems.minute = time->minute;
-  timeRtems.second = time->second;
-  timeRtems.ticks = time->usecond * getTicksPerSecond() / 1e6;
+  timeRtems.year = time_tod.year;
+  timeRtems.month = time_tod.month;
+  timeRtems.day = time_tod.day;
+  timeRtems.hour = time_tod.hour;
+  timeRtems.minute = time_tod.minute;
+  timeRtems.second = time_tod.second;
+  timeRtems.ticks = static_cast<uint64_t>(time_tod.usecond) * rtems_clock_get_ticks_per_second() / 1e6;
   rtems_status_code status = rtems_clock_set(&timeRtems);
   switch (status) {
     case RTEMS_SUCCESSFUL:
@@ -33,27 +34,6 @@ ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
   }
 }
 
-ReturnValue_t Clock::setClock(const timeval* time) {
-  timespec newTime;
-  newTime.tv_sec = time->tv_sec;
-  if (time->tv_usec < 0) {
-    // better returnvalue.
-    return returnvalue::FAILED;
-  }
-  newTime.tv_nsec = time->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
-
-  ISR_lock_Context context;
-  _TOD_Lock();
-  _TOD_Acquire(&context);
-  Status_Control status = _TOD_Set(&newTime, &context);
-  _TOD_Unlock();
-  if (status == STATUS_SUCCESSFUL) {
-    return returnvalue::OK;
-  }
-  // better returnvalue
-  return returnvalue::FAILED;
-}
-
 ReturnValue_t Clock::getClock_timeval(timeval* time) {
   // Callable from ISR
   rtems_status_code status = rtems_clock_get_tod_timeval(time);
@@ -67,86 +47,13 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
   }
 }
 
-ReturnValue_t Clock::getUptime(timeval* uptime) {
+timeval Clock::getUptime() {
   // According to docs.rtems.org for rtems 5 this method is more accurate than
   // rtems_clock_get_ticks_since_boot
+  timeval time_timeval;
   timespec time;
   rtems_status_code status = rtems_clock_get_uptime(&time);
-  uptime->tv_sec = time.tv_sec;
-  time.tv_nsec = time.tv_nsec / 1000;
-  uptime->tv_usec = time.tv_nsec;
-  switch (status) {
-    case RTEMS_SUCCESSFUL:
-      return returnvalue::OK;
-    default:
-      return returnvalue::FAILED;
-  }
-}
-
-ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-  // This counter overflows after 50 days
-  *uptimeMs = rtems_clock_get_ticks_since_boot();
-  return returnvalue::OK;
-}
-
-ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-  timeval temp_time;
-  rtems_status_code returnValue = rtems_clock_get_tod_timeval(&temp_time);
-  *time = ((uint64_t)temp_time.tv_sec * 1000000) + temp_time.tv_usec;
-  switch (returnValue) {
-    case RTEMS_SUCCESSFUL:
-      return returnvalue::OK;
-    default:
-      return returnvalue::FAILED;
-  }
-}
-
-ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-  /* For all but the last field, the struct will be filled with the correct values */
-  rtems_time_of_day timeRtems;
-  rtems_status_code status = rtems_clock_get_tod(&timeRtems);
-  switch (status) {
-    case RTEMS_SUCCESSFUL: {
-      /* The last field now contains the RTEMS ticks of the seconds from 0
-      to rtems_clock_get_ticks_per_second() minus one.
-      We calculate the microseconds accordingly */
-      time->day = timeRtems.day;
-      time->hour = timeRtems.hour;
-      time->minute = timeRtems.minute;
-      time->month = timeRtems.month;
-      time->second = timeRtems.second;
-      time->usecond =
-          static_cast<float>(timeRtems.ticks) / rtems_clock_get_ticks_per_second() * 1e6;
-      time->year = timeRtems.year;
-      return returnvalue::OK;
-    }
-    case RTEMS_NOT_DEFINED:
-      /* System date and time is not set */
-      return returnvalue::FAILED;
-    case RTEMS_INVALID_ADDRESS:
-      /* time_buffer is NULL */
-      return returnvalue::FAILED;
-    default:
-      return returnvalue::FAILED;
-  }
-}
-
-ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
-  // Fails in 2038..
-  rtems_time_of_day timeRtems;
-  timeRtems.year = from->year;
-  timeRtems.month = from->month;
-  timeRtems.day = from->day;
-  timeRtems.hour = from->hour;
-  timeRtems.minute = from->minute;
-  timeRtems.second = from->second;
-  timeRtems.ticks = from->usecond * getTicksPerSecond() / 1e6;
-  to->tv_sec = _TOD_To_seconds(&timeRtems);
-  to->tv_usec = from->usecond;
-  return returnvalue::OK;
-}
-
-ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-  *JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24. / 3600.;
-  return returnvalue::OK;
-}
+  time_timeval.tv_sec = time.tv_sec;
+  time_timeval.tv_usec = time.tv_nsec / 1000;
+  return time_timeval;
+}

src/fsfw/osal/rtems/CpuUsage.cpp

@@ -93,8 +93,8 @@ ReturnValue_t CpuUsage::serialize(uint8_t** buffer, size_t* size, size_t maxSize
                                                        streamEndianness);
 }
 
-uint32_t CpuUsage::getSerializedSize() const {
-  uint32_t size = 0;
+size_t CpuUsage::getSerializedSize() const {
+  size_t size = 0;
 
   size += sizeof(timeSinceLastReset);
   size += SerialArrayListAdapter<ThreadData>::getSerializedSize(&threadData);
@@ -136,8 +136,8 @@ ReturnValue_t CpuUsage::ThreadData::serialize(uint8_t** buffer, size_t* size, si
   return returnvalue::OK;
 }
 
-uint32_t CpuUsage::ThreadData::getSerializedSize() const {
-  uint32_t size = 0;
+size_t CpuUsage::ThreadData::getSerializedSize() const {
+  size_t size = 0;
 
   size += sizeof(id);
   size += MAX_LENGTH_OF_THREAD_NAME;

src/fsfw/osal/rtems/InternalErrorCodes.cpp

@@ -35,10 +35,9 @@ ReturnValue_t InternalErrorCodes::translate(uint8_t code) {
       return OUT_OF_PROXIES;
     case INTERNAL_ERROR_INVALID_GLOBAL_ID:
       return INVALID_GLOBAL_ID;
-#ifndef STM32H743ZI_NUCLEO
-    case INTERNAL_ERROR_BAD_STACK_HOOK:
-      return BAD_STACK_HOOK;
-#endif
+    //TODO this one is not there anymore in rtems-6 (5 as well?)
+    //case INTERNAL_ERROR_BAD_STACK_HOOK:
+    //  return BAD_STACK_HOOK;
       //	case INTERNAL_ERROR_BAD_ATTRIBUTES:
       //		return BAD_ATTRIBUTES;
       //	case INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY:

src/fsfw/osal/rtems/SemaphoreFactory.cpp

@@ -18,7 +18,9 @@ SemaphoreFactory* SemaphoreFactory::instance() {
 }
 
 SemaphoreIF* SemaphoreFactory::createBinarySemaphore(uint32_t argument) {
-  return new BinarySemaphore();
+  return nullptr;
+  //TODO
+  //return new BinarySemaphore();
 }
 
 SemaphoreIF* SemaphoreFactory::createCountingSemaphore(uint8_t maxCount, uint8_t initCount,

src/fsfw/pus/Service9TimeManagement.cpp

@@ -33,13 +33,12 @@ ReturnValue_t Service9TimeManagement::setTime() {
     return result;
   }
 
-  uint32_t formerUptime;
-  Clock::getUptime(&formerUptime);
+  // TODO maybe switch to getClock_usecs to report more meaningful data
+  uint32_t formerUptime = Clock::getUptime_ms();
   result = Clock::setClock(&timeToSet);
 
   if (result == returnvalue::OK) {
-    uint32_t newUptime;
-    Clock::getUptime(&newUptime);
+    uint32_t newUptime = Clock::getUptime_ms();
     triggerEvent(CLOCK_SET, newUptime, formerUptime);
     return returnvalue::OK;
   } else {

src/fsfw/subsystem/Subsystem.cpp

@@ -91,11 +91,10 @@ void Subsystem::performChildOperation() {
       }
       if (currentSequenceIterator->getWaitSeconds() != 0) {
         if (uptimeStartTable == 0) {
-          Clock::getUptime(&uptimeStartTable);
+          uptimeStartTable = Clock::getUptime_ms();
           return;
         } else {
-          uint32_t uptimeNow;
-          Clock::getUptime(&uptimeNow);
+          uint32_t uptimeNow = Clock::getUptime_ms();
           if ((uptimeNow - uptimeStartTable) < (currentSequenceIterator->getWaitSeconds() * 1000)) {
             return;
           }

src/fsfw/thermal/Heater.cpp

@@ -198,10 +198,9 @@ void Heater::setSwitch(uint8_t number, ReturnValue_t state, uint32_t* uptimeOfSw
   } else {
     if ((*uptimeOfSwitching == INVALID_UPTIME)) {
       powerSwitcher->sendSwitchCommand(number, state);
-      Clock::getUptime(uptimeOfSwitching);
+      *uptimeOfSwitching = Clock::getUptime_ms();
     } else {
-      uint32_t currentUptime;
-      Clock::getUptime(&currentUptime);
+      uint32_t currentUptime = Clock::getUptime_ms();
       if (currentUptime - *uptimeOfSwitching > powerSwitcher->getSwitchDelayMs()) {
         *uptimeOfSwitching = INVALID_UPTIME;
         if (healthHelper.healthTable->isHealthy(getObjectId())) {

src/fsfw/timemanager/Clock.h

@@ -14,8 +14,10 @@
 #include <ctime>
 #endif
 
+
 class Clock {
  public:
+ // https://xkcd.com/927/
   typedef struct {
     uint32_t year;     //!< Year, A.D.
     uint32_t month;    //!< Month, 1 .. 12.
@@ -26,14 +28,6 @@ class Clock {
     uint32_t usecond;  //!< Microseconds, 0 .. 999999
   } TimeOfDay_t;
 
-  /**
-   * This method returns the number of clock ticks per second.
-   * In RTEMS, this is typically 1000.
-   * @return	The number of ticks.
-   *
-   * @deprecated, we should not worry about ticks, but only time
-   */
-  static uint32_t getTicksPerSecond();
   /**
    * This system call sets the system time.
    * To set the time, it uses a TimeOfDay_t struct.
@@ -61,13 +55,8 @@ class Clock {
   /**
    * Get the time since boot in a timeval struct
    *
-   * @param[out] time A pointer to a timeval struct where the uptime is stored.
-   * @return @c returnvalue::OK on success. Otherwise, the OS failure code is returned.
-   *
-   * @deprecated, I do not think this should be able to fail, use timeval getUptime()
+   * @return a timeval struct where the uptime is stored
    */
-  static ReturnValue_t getUptime(timeval *uptime);
-
   static timeval getUptime();
 
   /**
@@ -79,7 +68,7 @@ class Clock {
    * @param ms uptime in ms
    * @return returnvalue::OK on success. Otherwise, the OS failure code is returned.
    */
-  static ReturnValue_t getUptime(uint32_t *uptimeMs);
+  static uint32_t getUptime_ms();
 
   /**
    * Returns the time in microseconds since an OS-defined epoch.
@@ -90,6 +79,7 @@ class Clock {
    *  - Otherwise, the OS failure code is returned.
    */
   static ReturnValue_t getClock_usecs(uint64_t *time);
+
   /**
    * Returns the time in a TimeOfDay_t struct.
    * @param time A pointer to a TimeOfDay_t struct.
@@ -106,6 +96,7 @@ class Clock {
    * @return
    */
   static ReturnValue_t convertTimevalToTimeOfDay(const timeval *from, TimeOfDay_t *to);
+
   /**
    * Converts a time of day struct to POSIX seconds.
    * @param time The time of day as input

src/fsfw/timemanager/ClockCommon.cpp

@@ -1,4 +1,5 @@
 #include <ctime>
+#include <cstdlib>
 
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/timemanager/Clock.h"
@@ -53,34 +54,74 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 }
 
 ReturnValue_t Clock::convertTimevalToTimeOfDay(const timeval* from, TimeOfDay_t* to) {
-  struct tm* timeInfo;
-  // According to https://en.cppreference.com/w/c/chrono/gmtime, the implementation of gmtime_s
-  // in the Windows CRT is incompatible with the C standard but this should not be an issue for
-  // this implementation
-  ReturnValue_t result = checkOrCreateClockMutex();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  // gmtime writes its output in a global buffer which is not Thread Safe
-  // Therefore we have to use a Mutex here
-  MutexGuard helper(timeMutex);
+  struct tm time_tm;
+  // WINDOWS does not provide gmtime_r, but gmtime_s
 #ifdef PLATFORM_WIN
-  time_t time;
-  time = from->tv_sec;
-  timeInfo = gmtime(&time);
+  errno_t result = gmtime_s(&time_tm, &from->tv_sec);
+  if (result != 0) {
+    return returnvalue::FAILED;
+  }
 #else
-  timeInfo = gmtime(&from->tv_sec);
+  void* result = gmtime_r(&from->tv_sec, &time_tm);
+
+  if (result == nullptr) {
+    return returnvalue::FAILED;
+  }
 #endif
-  to->year = timeInfo->tm_year + 1900;
-  to->month = timeInfo->tm_mon + 1;
-  to->day = timeInfo->tm_mday;
-  to->hour = timeInfo->tm_hour;
-  to->minute = timeInfo->tm_min;
-  to->second = timeInfo->tm_sec;
+
+  to->year = time_tm.tm_year + 1900;
+  to->month = time_tm.tm_mon + 1;
+  to->day = time_tm.tm_mday;
+  to->hour = time_tm.tm_hour;
+  to->minute = time_tm.tm_min;
+  to->second = time_tm.tm_sec;
   to->usecond = from->tv_usec;
   return returnvalue::OK;
 }
 
+ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
+  struct tm time_tm = {};
+
+  time_tm.tm_year = from->year - 1900;
+  time_tm.tm_mon = from->month - 1;
+  time_tm.tm_mday = from->day;
+
+  time_tm.tm_hour = from->hour;
+  time_tm.tm_min = from->minute;
+  time_tm.tm_sec = from->second;
+
+  time_tm.tm_isdst = 0;
+
+  // Windows:
+  // time_t seconds = _mkgmtime(&time_tm);
+  // Glibc:
+  // time_t seconds = timegm(&time_tm);
+  // Portable (?)
+  char* tz;
+  tz = getenv("TZ");
+  setenv("TZ", "", 1);
+  tzset();
+  time_t seconds = mktime(&time_tm);
+  if (tz)
+    setenv("TZ", tz, 1);
+  else
+    unsetenv("TZ");
+  tzset();
+  to->tv_sec = seconds;
+  to->tv_usec = from->usecond;
+
+  if (seconds == (time_t) -1) {
+    return returnvalue::FAILED;
+  }
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
+  *JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24. / 3600.;
+  return returnvalue::OK;
+}
+
 ReturnValue_t Clock::checkOrCreateClockMutex() {
   if (timeMutex == nullptr) {
     MutexFactory* mutexFactory = MutexFactory::instance();
@@ -94,3 +135,37 @@ ReturnValue_t Clock::checkOrCreateClockMutex() {
   }
   return returnvalue::OK;
 }
+
+ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
+  timeval time_timeval;
+  ReturnValue_t result = getClock_timeval(&time_timeval);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return convertTimevalToTimeOfDay(&time_timeval, time);
+}
+
+ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
+  timeval timeVal{};
+  ReturnValue_t result = getClock_timeval(&timeVal);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  *time = static_cast<uint64_t>(timeVal.tv_sec) * 1e6 + timeVal.tv_usec;
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
+  timeval timeTimeval{};
+  ReturnValue_t result = convertTimeOfDayToTimeval(time, &timeTimeval);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return setClock(&timeTimeval);
+}
+uint32_t Clock::getUptime_ms() {
+  timeval uptime = getUptime();
+  // TODO verify that overflow is correct
+  return uptime.tv_sec * 1e3 + uptime.tv_usec / 1e3;
+}

src/fsfw/timemanager/Countdown.cpp

@@ -7,9 +7,9 @@ Countdown::Countdown(uint32_t initialTimeout) : timeout(initialTimeout) {
 Countdown::~Countdown() {}
 
 ReturnValue_t Countdown::setTimeout(uint32_t milliseconds) {
-  ReturnValue_t returnValue = Clock::getUptime(&startTime);
+  startTime = Clock::getUptime_ms();
   timeout = milliseconds;
-  return returnValue;
+  return returnvalue::OK;
 }
 
 bool Countdown::hasTimedOut() const {
@@ -39,7 +39,5 @@ uint32_t Countdown::getRemainingMillis() const {
 }
 
 uint32_t Countdown::getCurrentTime() const {
-  uint32_t currentTime;
-  Clock::getUptime(&currentTime);
-  return currentTime;
+  return Clock::getUptime_ms();
 }

src/fsfw/timemanager/Stopwatch.cpp

@@ -9,10 +9,10 @@
 Stopwatch::Stopwatch(bool displayOnDestruction, StopwatchDisplayMode displayMode)
     : displayOnDestruction(displayOnDestruction), displayMode(displayMode) {
   // Measures start time on initialization.
-  Clock::getUptime(&startTime);
+  startTime = Clock::getUptime();
 }
 
-void Stopwatch::start() { Clock::getUptime(&startTime); }
+void Stopwatch::start() { startTime = Clock::getUptime(); }
 
 dur_millis_t Stopwatch::stop(bool display) {
   stopInternal();
@@ -62,7 +62,6 @@ void Stopwatch::setDisplayMode(StopwatchDisplayMode displayMode) {
 StopwatchDisplayMode Stopwatch::getDisplayMode() const { return displayMode; }
 
 void Stopwatch::stopInternal() {
-  timeval endTime;
-  Clock::getUptime(&endTime);
+  timeval endTime = Clock::getUptime();
   elapsedTime = endTime - startTime;
 }

src/fsfw/timemanager/TimeReaderIF.h

@@ -3,6 +3,8 @@
 
 #include <cstdio>
 #include <cstdlib>
+#include <sys/time.h>
+
 
 #include "fsfw/platform.h"
 

src/fsfw/tmtcservices/CommandingServiceBase.cpp

@@ -348,7 +348,7 @@ void CommandingServiceBase::startExecution(store_address_t storeId, CommandMapIt
         sendResult = commandQueue->sendMessage(iter.value->first, &command);
       }
       if (sendResult == returnvalue::OK) {
-        Clock::getUptime(&iter->second.uptimeOfStart);
+        iter->second.uptimeOfStart = Clock::getUptime_ms();
         iter->second.step = 0;
         iter->second.subservice = tcReader.getSubService();
         iter->second.command = command.getCommand();
@@ -434,8 +434,7 @@ inline void CommandingServiceBase::doPeriodicOperation() {}
 MessageQueueId_t CommandingServiceBase::getCommandQueue() { return commandQueue->getId(); }
 
 void CommandingServiceBase::checkTimeout() {
-  uint32_t uptime;
-  Clock::getUptime(&uptime);
+  uint32_t uptime = Clock::getUptime_ms();
   CommandMapIter iter;
   for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
     if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {

unittests/CMakeLists.txt

@@ -20,7 +20,9 @@ add_subdirectory(globalfunctions)
 add_subdirectory(timemanager)
 add_subdirectory(tmtcpacket)
 add_subdirectory(cfdp)
+IF(NOT FSFW_OSAL MATCHES "rtems")
 add_subdirectory(hal)
+ENDIF()
 add_subdirectory(internalerror)
 add_subdirectory(devicehandler)
 add_subdirectory(tmtcservices)

unittests/CatchRunner.cpp

@@ -43,6 +43,66 @@ void unittestTaskFunction(void* pvParameters) {
 }
 #endif
 
+#ifdef FSFW_OSAL_RTEMS
+#include <signal.h>
+
+int sigaltstack(const stack_t* ss, stack_t* old_ss) { return 0; }
+extern "C" {
+
+void exit_qemu_failing(int error) {
+  asm(/* 0x20026 == ADP_Stopped_ApplicationExit */
+         "mov x1, #0x26\n\t"
+        "movk x1, #2, lsl #16\n\t"
+        "str x1, [sp,#0]\n\t");
+
+    /* Exit status code. Host QEMU process exits with that status. */
+    asm("mov x0, %[error]\n\t" : : [error] "r" (error));
+    asm(
+        "str x0, [sp,#8]\n\t"
+
+    /* x1 contains the address of parameter block.
+     * Any memory address could be used. */
+        "mov x1, sp\n\t"
+
+    /* SYS_EXIT */
+        "mov w0, #0x18\n\t"
+
+    /* Do the semihosting call on A64. */
+        "hlt 0xf000\n\t"
+);
+}
+
+#include <rtemsConfig.h>
+
+void user_handle_fatal(Internal_errors_Source source, bool internal,  Internal_errors_t error_code){
+  if ( source == RTEMS_FATAL_SOURCE_EXIT ) {
+    if (error_code != 0) {
+      printk("*** EXIT STATUS NOT ZERO ***\n");
+      printk("Quitting qemu with exit code %i\n", error_code);
+      exit_qemu_failing(error_code);
+    }
+  }
+}
+
+rtems_task Init(rtems_task_argument ignored) {
+  rtems_time_of_day now;
+  now.year = 2023;
+  now.month = 1;
+  now.day = 15;
+  now.hour = 0;
+  now.minute = 0;
+  now.second = 0;
+  now.ticks = 0;
+  rtems_clock_set(&now);
+  customSetup();
+  const char* argv[] = {"fsfw-test", ""};
+  int result = Catch::Session().run(1, argv);
+  customTeardown();
+  exit(result);
+}
+}
+#endif
+
 int main(int argc, char* argv[]) {
   customSetup();
 

unittests/osal/CMakeLists.txt

@@ -1,2 +1,5 @@
-target_sources(${FSFW_TEST_TGT} PRIVATE testMq.cpp TestSemaphore.cpp
-                                        TestClock.cpp)
+target_sources(${FSFW_TEST_TGT} PRIVATE testMq.cpp TestClock.cpp)
+
+if(FSFW_OSAL MATCHES "linux" OR FSFW_OSAL MATCHES "freertos")
+target_sources(${FSFW_TEST_TGT} PRIVATE TestSemaphore.cpp)
+endif()

unittests/osal/TestClock.cpp

@@ -8,6 +8,8 @@
 
 #include "CatchDefinitions.h"
 
+//TODO setClock()
+
 TEST_CASE("OSAL::Clock Test", "[OSAL::Clock Test]") {
   SECTION("Test getClock") {
     timeval time;
@@ -22,7 +24,7 @@ TEST_CASE("OSAL::Clock Test", "[OSAL::Clock Test]") {
     // We require timeOfDayAsTimeval to be larger than time as it
     // was request a few ns later
     double difference = timevalOperations::toDouble(timeOfDayAsTimeval - time);
-    CHECK(difference >= 0.0);
+    CHECK(difference >= 0);
     CHECK(difference <= 0.005);
 
     // Conversion in the other direction

unittests/osal/TestSemaphore.cpp

@@ -4,8 +4,6 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-// binary semaphores currently only supported on linux
-#if defined(FSFW_OSAL_LINUX) || defined(FSFW_OSAL_FREERTOS)
 
 TEST_CASE("Binary Semaphore Test", "[BinSemaphore]") {
   // perform set-up here
@@ -33,6 +31,4 @@ TEST_CASE("Binary Semaphore Test", "[BinSemaphore]") {
 
 TEST_CASE("Counting Semaphore Test", "[CountingSemaph]") {
   SECTION("Simple Test") {}
-}
-
-#endif
+}

unittests/testcfg/rtems/cmake/Platform/a72_lp64_qemu.cmake

@@ -0,0 +1,3 @@
+add_compile_options("-mcpu=cortex-a72" "-I/opt/rtems/6/aarch64-rtems6/a72_lp64_qemu/lib/include")
+
+add_link_options("-B/opt/rtems/6/aarch64-rtems6/a72_lp64_qemu/lib" "-qrtems")

unittests/testcfg/rtems/cmake/aarch64-rtems6-toolchain.cmake

@@ -0,0 +1,36 @@
+## the name of the target operating system
+set(CMAKE_SYSTEM_NAME a72_lp64_qemu)
+
+set(CMAKE_SYSTEM_PROCESSOR a72)
+
+# which compilers to use for C and C++
+set(CMAKE_C_COMPILER   aarch64-rtems6-gcc)
+set(CMAKE_CXX_COMPILER aarch64-rtems6-g++)
+
+# built in tests fail
+set(CMAKE_C_COMPILER_WORKS 1)
+set(CMAKE_CXX_COMPILER_WORKS 1)
+
+# adjust the default behavior of the FIND_XXX() commands:
+# search programs in the host environment
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
+
+# search headers and libraries in the target environment
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+# ignore host installed libraries
+# makes find_package() ignore the <package>Config.cmake files
+set(CMAKE_IGNORE_PATH /usr/local)
+
+
+# supress errors
+add_compile_definitions("__STDC_VERSION__")
+
+# make newlib behave like glib with an intercepted cmath
+add_compile_options("-I${CMAKE_SOURCE_DIR}/unittests/testcfg/rtems/include")
+
+# we supply an a72_lp64_qemu.cmake there
+list(APPEND CMAKE_MODULE_PATH
+     "${CMAKE_CURRENT_SOURCE_DIR}/unittests/testcfg/rtems/cmake")

unittests/testcfg/rtems/include/cmath

@@ -0,0 +1,39 @@
+#pragma once
+
+#include_next <cmath>
+
+extern "C++"
+{
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+
+#undef lround
+#undef erfc
+#undef round
+
+
+using ::lround;
+
+long
+  lround(float __x);
+
+  constexpr long
+  lround(long double __x);
+
+using ::erfc;
+  
+constexpr float
+  erfc(float __x);
+
+  constexpr long double
+  erfc(long double __x);
+  
+  constexpr float
+  round(float __x);
+
+  using ::round;
+  
+  constexpr long double
+  round(long double __x);
+}
+}

unittests/testcfg/rtems/include/rtemsConfig.h

@@ -0,0 +1,32 @@
+#pragma once
+
+
+#include <rtems/extension.h>
+#include <rtems/bspIo.h>
+void user_handle_fatal(Internal_errors_Source source, bool internal,  Internal_errors_t error_code);
+
+#define RTEMS_USE_UNLIMITED_OBJECTS_ALLOCATION 0
+
+#define CONFIGURE_MICROSECONDS_PER_TICK 1000
+
+#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
+
+#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
+#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
+
+#define CONFIGURE_MAXIMUM_TASKS 20
+#define CONFIGURE_MAXIMUM_MESSAGE_QUEUES 30
+#define CONFIGURE_MAXIMUM_SEMAPHORES 20
+#define CONFIGURE_MAXIMUM_TIMERS 10
+//! Required for Rate-Monotonic Scheduling (RMS)
+#define CONFIGURE_MAXIMUM_PERIODS 15
+#define CONFIGURE_INIT_TASK_STACK_SIZE (RTEMS_MINIMUM_STACK_SIZE * 6)
+//! Around 41 kB extra task stack for now.
+#define CONFIGURE_EXTRA_TASK_STACKS (10 * RTEMS_MINIMUM_STACK_SIZE)
+
+#define CONFIGURE_INITIAL_EXTENSIONS { NULL, NULL, NULL, NULL, NULL, NULL, NULL, user_handle_fatal, NULL }
+
+#define CONFIGURE_INIT
+
+#include <rtems.h>
+#include <rtems/confdefs.h>