Merge branch 'mohr/rtems' into windows

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

@@ -10,16 +10,120 @@
 
 #define CATCH_CONFIG_COLOUR_WINDOWS
 
+#include <fsfw/osal/osal.h>
+
 #include <catch2/catch_session.hpp>
 
+#ifdef FSFW_OSAL_FREERTOS
+#include <FreeRTOS.h>
+
+#include "task.h"
+#endif
+
 extern int customSetup();
 extern int customTeardown();
 
+#ifdef FSFW_OSAL_FREERTOS
+struct Taskparameters {
+  int argc;
+  char** argv;
+  TaskHandle_t catchTask;
+} taskParameters;
+
+void unittestTaskFunction(void* pvParameters) {
+  Taskparameters* parameters = (Taskparameters*)pvParameters;
+
+  int result = Catch::Session().run(parameters->argc, parameters->argv);
+
+  vTaskDelay(pdMS_TO_TICKS(10));
+  vTaskSuspendAll();
+  vTaskDelete(parameters->catchTask);
+  customTeardown();
+  exit(result);
+}
+#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();
 
+  int result = 0;
+
+#ifdef FSFW_OSAL_FREERTOS
+  xTaskCreate(
+      unittestTaskFunction, /* The function that implements the task. */
+      "Unittests", /* The text name assigned to the task - for debug only as it is not used by the
+                      kernel. */
+      configMINIMAL_STACK_SIZE, /* The size of the stack to allocate to the task. */
+      &taskParameters, /* The parameter passed to the task - not used in this simple case. */
+      1,               /* The priority assigned to the task. */
+      &taskParameters.catchTask); /* The task handle is not required, so NULL is passed. */
+  taskParameters.argc = argc;
+  taskParameters.argv = argv;
+  vTaskStartScheduler();
+#else
   // Catch internal function call
-  int result = Catch::Session().run(argc, argv);
+  result = Catch::Session().run(argc, argv);
+#endif
 
   // global clean-up
   customTeardown();

unittests/CatchSetup.cpp

@@ -31,4 +31,7 @@ int customSetup() {
   return 0;
 }
 
-int customTeardown() { return 0; }
+int customTeardown() {
+  ObjectManager::clear();
+  return 0;
+}

unittests/devicehandler/DeviceHandlerCommander.cpp

@@ -9,7 +9,9 @@ DeviceHandlerCommander::DeviceHandlerCommander(object_id_t objectId)
       QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
-DeviceHandlerCommander::~DeviceHandlerCommander() {}
+DeviceHandlerCommander::~DeviceHandlerCommander() {
+  QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
 
 ReturnValue_t DeviceHandlerCommander::performOperation(uint8_t operationCode) {
   readCommandQueue();

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

@@ -1,5 +1,6 @@
 #include <fsfw/globalfunctions/timevalOperations.h>
 #include <fsfw/timemanager/Clock.h>
+#include <stdio.h>
 
 #include <array>
 #include <catch2/catch_approx.hpp>
@@ -7,6 +8,8 @@
 
 #include "CatchDefinitions.h"
 
+//TODO setClock()
+
 TEST_CASE("OSAL::Clock Test", "[OSAL::Clock Test]") {
   SECTION("Test getClock") {
     timeval time;
@@ -21,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

@@ -1,46 +1,34 @@
-
-#ifdef LINUX
-
-/*
+#include <fsfw/osal/osal.h>
 #include <fsfw/tasks/SemaphoreFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
 
-#include "catch.hpp"
-#include "core/CatchDefinitions.h"
+#include <catch2/catch_test_macros.hpp>
 
-TEST_CASE("Binary Semaphore Test" , "[BinSemaphore]") {
-        //perform set-up here
-        SemaphoreIF* binSemaph = SemaphoreFactory::instance()->
-                        createBinarySemaphore();
-        REQUIRE(binSemaph != nullptr);
-        SECTION("Simple Test") {
-                // set-up is run for each section
-                REQUIRE(binSemaph->getSemaphoreCounter() == 1);
-                REQUIRE(binSemaph->release() ==
-                                static_cast<int>(SemaphoreIF::SEMAPHORE_NOT_OWNED));
-                REQUIRE(binSemaph->acquire(SemaphoreIF::POLLING) ==
-                                result::OK);
-                {
-                        // not precise enough on linux.. should use clock instead..
-                        //Stopwatch stopwatch(false);
-                        //REQUIRE(binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 5) ==
-                        //		SemaphoreIF::SEMAPHORE_TIMEOUT);
-                        //dur_millis_t time = stopwatch.stop();
-                        //CHECK(time == 5);
-                }
-                REQUIRE(binSemaph->getSemaphoreCounter() == 0);
-                REQUIRE(binSemaph->release() == result::OK);
-        }
-        SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
-        // perform tear-down here
+
+TEST_CASE("Binary Semaphore Test", "[BinSemaphore]") {
+  // perform set-up here
+  SemaphoreIF* binSemaph = SemaphoreFactory::instance()->createBinarySemaphore();
+  REQUIRE(binSemaph != nullptr);
+  SECTION("Simple Test") {
+    // set-up is run for each section
+    REQUIRE(binSemaph->getSemaphoreCounter() == 1);
+    REQUIRE(binSemaph->release() == static_cast<int>(SemaphoreIF::SEMAPHORE_NOT_OWNED));
+    REQUIRE(binSemaph->acquire(SemaphoreIF::POLLING) == returnvalue::OK);
+    {
+      // not precise enough on linux.. should use clock instead..
+      // Stopwatch stopwatch(false);
+      // REQUIRE(binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 5) ==
+      //		SemaphoreIF::SEMAPHORE_TIMEOUT);
+      // dur_millis_t time = stopwatch.stop();
+      // CHECK(time == 5);
+    }
+    REQUIRE(binSemaph->getSemaphoreCounter() == 0);
+    REQUIRE(binSemaph->release() == returnvalue::OK);
+  }
+  SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
+  // perform tear-down here
 }
 
-
-TEST_CASE("Counting Semaphore Test" , "[CountingSemaph]") {
-        SECTION("Simple Test") {
-
-        }
-}
-*/
-
-#endif
+TEST_CASE("Counting Semaphore Test", "[CountingSemaph]") {
+  SECTION("Simple Test") {}
+}

unittests/testcfg/freertos/FreeRTOSConfig.h

@@ -0,0 +1,102 @@
+#ifndef FREERTOS_CONFIG_H
+#define FREERTOS_CONFIG_H
+
+#define configUSE_PREEMPTION 1
+#define configUSE_PORT_OPTIMISED_TASK_SELECTION 0
+#define configUSE_TICKLESS_IDLE 0
+#define configTICK_RATE_HZ 1000
+#define configMAX_PRIORITIES 5
+#define configMINIMAL_STACK_SIZE ((unsigned short)PTHREAD_STACK_MIN)
+#define configMAX_TASK_NAME_LEN 16
+#define configUSE_16_BIT_TICKS 0
+#define configIDLE_SHOULD_YIELD 1
+#define configUSE_TASK_NOTIFICATIONS 1
+#define configTASK_NOTIFICATION_ARRAY_ENTRIES 3
+#define configUSE_MUTEXES 1
+#define configUSE_RECURSIVE_MUTEXES 0
+#define configUSE_COUNTING_SEMAPHORES 1
+#define configUSE_ALTERNATIVE_API 0 /* Deprecated! */
+#define configQUEUE_REGISTRY_SIZE 20
+#define configUSE_QUEUE_SETS 0
+#define configUSE_TIME_SLICING 0
+#define configUSE_NEWLIB_REENTRANT 0
+#define configENABLE_BACKWARD_COMPATIBILITY 1
+#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 5
+#define configUSE_MINI_LIST_ITEM 1
+#define configSTACK_DEPTH_TYPE uint16_t
+#define configMESSAGE_BUFFER_LENGTH_TYPE size_t
+#define configHEAP_CLEAR_MEMORY_ON_FREE 1
+
+/* Memory allocation related definitions. */
+#define configSUPPORT_STATIC_ALLOCATION 0
+#define configSUPPORT_DYNAMIC_ALLOCATION 1
+#define configTOTAL_HEAP_SIZE ((size_t)(1024 * 1024))
+#define configAPPLICATION_ALLOCATED_HEAP 1
+#define configSTACK_ALLOCATION_FROM_SEPARATE_HEAP 0
+
+/* Hook function related definitions. */
+#define configUSE_IDLE_HOOK 0
+#define configUSE_TICK_HOOK 0
+#define configCHECK_FOR_STACK_OVERFLOW 0
+#define configUSE_MALLOC_FAILED_HOOK 0
+#define configUSE_DAEMON_TASK_STARTUP_HOOK 0
+#define configUSE_SB_COMPLETED_CALLBACK 0
+
+/* Run time and task stats gathering related definitions. */
+#define configGENERATE_RUN_TIME_STATS 0
+#define configUSE_TRACE_FACILITY 0
+#define configUSE_STATS_FORMATTING_FUNCTIONS 0
+
+/* Co-routine related definitions. */
+#define configUSE_CO_ROUTINES 0
+#define configMAX_CO_ROUTINE_PRIORITIES 1
+
+/* Software timer related definitions. */
+#define configUSE_TIMERS 1
+#define configTIMER_TASK_PRIORITY 3
+#define configTIMER_QUEUE_LENGTH 10
+#define configTIMER_TASK_STACK_DEPTH configMINIMAL_STACK_SIZE
+
+/* Interrupt nesting behaviour configuration. */
+#define configKERNEL_INTERRUPT_PRIORITY [dependent of processor]
+#define configMAX_SYSCALL_INTERRUPT_PRIORITY [dependent on processor and application]
+#define configMAX_API_CALL_INTERRUPT_PRIORITY [dependent on processor and application]
+
+/* Define to trap errors during development. */
+//#define configASSERT( ( x ) ) if( ( x ) == 0 ) vAssertCalled( __FILE__, __LINE__ )
+
+/* FreeRTOS MPU specific definitions. */
+#define configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS 0
+#define configTOTAL_MPU_REGIONS 8    /* Default value. */
+#define configTEX_S_C_B_FLASH 0x07UL /* Default value. */
+#define configTEX_S_C_B_SRAM 0x07UL  /* Default value. */
+#define configENFORCE_SYSTEM_CALLS_FROM_KERNEL_ONLY 1
+#define configALLOW_UNPRIVILEGED_CRITICAL_SECTIONS 1
+#define configENABLE_ERRATA_837070_WORKAROUND 1
+
+/* ARMv8-M secure side port related definitions. */
+#define secureconfigMAX_SECURE_CONTEXTS 5
+
+/* Optional functions - most linkers will remove unused functions anyway. */
+#define INCLUDE_vTaskPrioritySet 1
+#define INCLUDE_uxTaskPriorityGet 1
+#define INCLUDE_vTaskDelete 1
+#define INCLUDE_vTaskSuspend 1
+#define INCLUDE_xResumeFromISR 1
+#define INCLUDE_vTaskDelayUntil 1
+#define INCLUDE_vTaskDelay 1
+#define INCLUDE_xTaskGetSchedulerState 1
+#define INCLUDE_xTaskGetCurrentTaskHandle 1
+#define INCLUDE_uxTaskGetStackHighWaterMark 0
+#define INCLUDE_uxTaskGetStackHighWaterMark2 0
+#define INCLUDE_xTaskGetIdleTaskHandle 0
+#define INCLUDE_eTaskGetState 0
+#define INCLUDE_xEventGroupSetBitFromISR 1
+#define INCLUDE_xTimerPendFunctionCall 0
+#define INCLUDE_xTaskAbortDelay 0
+#define INCLUDE_xTaskGetHandle 0
+#define INCLUDE_xTaskResumeFromISR 1
+
+/* A header file that defines trace macro can be included here. */
+
+#endif /* FREERTOS_CONFIG_H */

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>